diff --git a/bin/rad-registry b/bin/rad-registry
index 0aa25623d..4867d9ccd 100755
--- a/bin/rad-registry
+++ b/bin/rad-registry
@@ -40,25 +40,25 @@
    Usage:
         rad registry list [--unread]
         rad registry new
-        rad registry [show | delete | mark-read | mark-unread] <project-number>
+        rad registry [show | delete | mark-read | mark-unread] <registered-machine-number>
         rad registry all-read
         rad registry init
         rad registry set <registry-id>
         rad registry help
 
-     list         - Lists all projects
-                    If the option '--unread' is appended, only unread projects
+     list         - Lists all registered Radicle machines
+                    If the option '--unread' is appended, only unread machines
                     are listed.
-                    Unread projects are marked with a * after the timestamp.
-     new          - Register a new project in $EDITOR
-     show         - Show a project
-     show-id      - Show the project id
-     delete       - Delete a project
+                    Unread machines are marked with a * after the timestamp.
+     new          - Register a new Radicle machine in $EDITOR
+     show         - Show a registered Radicle machine
+     show-id      - Show the registered Radicle machine id
+     delete       - Delete a Radicle machine from the registry
                     This command is restricted to the maintainer of the registry
                     and the registrant.
-     mark-read    - Mark project as read
-     mark-unread  - Mark project as unread
-     all-read     - Mark all projects as read
+     mark-read    - Mark registered Radicle machine as read
+     mark-unread  - Mark registered Radicle machine as unread
+     all-read     - Mark all registered Radicle machines as read
      init         - Initialize a new registry machine
      set          - Set the registry that is used for the commands instead of
                     the default. Delete the file to use the default registry.
@@ -69,64 +69,64 @@
   (fn [error]
     (parse-failure error help)))
 
-(def get-project
-  "Returns the project of given number `n`."
+(def get-registered-machine
+  "Returns the machine of given number `n`."
   (fn [n machine]
-    (items/verify-item-number n (list-projects machine) :project)))
+    (items/verify-item-number n (list-registered-machines machine) :registered-machine)))
 
-(def show-project!
-  "Shows a single PROJECT `n`"
+(def show-registered-machine!
+  "Shows a single MACHINE `n`"
   (fn [n machine]
-    (def project (get-project n machine))
-    (put-str! (items/pretty-item-view (items/enrich-item machine project)))
+    (def registered-machine (get-registered-machine n machine))
+    (put-str! (items/pretty-item-view (items/enrich-item machine registered-machine)))
     (newness/mark-read! machine n)))
 
-(def show-project-id!
-  "Shows the id of a single PROJECT `n`"
+(def show-registered-machine-id!
+  "Shows the id of a single MACHINE `n`"
   (fn [n machine]
-    (def project (get-project n machine))
-    (put-str! (lookup :project-id project))
+    (def registered-machine (get-registered-machine n machine))
+    (put-str! (lookup :registered-machine-id registered-machine))
     (newness/mark-read! machine n)))
 
-(def delete-project
+(def delete-registered-machine
   (fn [n machine]
     (catch 'daemon-error
       (do
-        (get-project n machine)
-        (delete-project! machine {:project-number n})
-        (put-str! (string-append "Project #" (show n) " has been deleted."))
+        (get-registered-machine n machine)
+        (delete-registered-machine! machine {:registered-machine-number n})
+        (put-str! (string-append "Radicle machine #" (show n) " has been deleted."))
         (newness/mark-read! machine n))
       (fn [_]
-        (put-str! (error/state-change-failure :project "deleted"))
+        (put-str! (error/state-change-failure :registered-machine "deleted"))
         (exit! 1)))))
 
 (def list
   (fn [machine options]
-    (def projects (values (list-projects machine)))
-    (items/list-items-plain machine options projects :project)))
+    (def registered-machines (values (list-registered-machines machine)))
+    (items/list-items-plain machine options registered-machines :registered-machine)))
 
 (def prompt-for-metadata!
   (fn []
     (def name (prompt-non-empty!
-                "? What's the name of your project: "
+                "? What's the name of your Radicle machine: "
                 \(not (eq? ? ""))
-                "Project name can't be empty!"))
-    (def desc (prompt! "? Briefly describe the project: "))
+                "Radicle machine name can't be empty!"))
+    (def desc (prompt! "? Briefly describe the Radicle machine: "))
     (def id (prompt-non-empty!
-              "? What's the id of your project: "
+              "? What's the id of your Radicle machine: "
               \(not (eq? ? ""))
-              "Project id can't be empty!"))
+              "Radicle machine id can't be empty!"))
     (def labels (prompt! "? Do you want to add any labels (comma seperated): "))
-    {:name name :description desc :project-id id :labels (split-by (fn [x] (eq? x ",")) labels)}))
+    {:name name :description desc :registered-machine-id id :labels (split-by (fn [x] (eq? x ",")) labels)}))
 
-(def new-project
+(def register-machine
   (fn [machine]
     (def meta (prompt-for-metadata!))
     (def author {:git-username (get-git-username!)})
-    (match (register-project!  machine (simple-project (<> meta author)))
-           ['n] (do (put-str! (string-append "Created project #" (show n) " in " machine))
+    (match (register-machine! machine (simple-registered-machine (<> meta author)))
+           ['n] (do (put-str! (string-append "Registered Radicle machine #" (show n) " in " machine))
                     (newness/mark-read! machine n))
-           _    (put-str! (error/no-number-returned :project)))))
+           _    (put-str! (error/no-number-returned :registered-machine)))))
 
 (def cmd-options
   [
@@ -139,14 +139,14 @@
 
 (def args (get-args!))
 
-(def whole-project-num
+(def whole-registered-machine-num
   (fn [action num-str f]
-    (whole-num help :project action num-str f)))
+    (whole-num help :registered-machine action num-str f)))
 
 (def mark-all-read!
   (fn [machine]
     (map (fn [i] (newness/mark-read! machine (lookup :number i)))
-         (values (list-projects machine)))))
+         (values (list-registered-machines machine)))))
 
 (def new-registry!
   (fn []
@@ -164,14 +164,14 @@
  (fn []
    (match args
           (/list-cmd 'options)           (list (machine-name) options)
-          (/cmd-0 "new" help)            (new-project (machine-name))
+          (/cmd-0 "new" help)            (register-machine (machine-name))
           (/cmd-0 "init" help)           (new-registry!)
           (/cmd-1 "set" 'n help)         (set-registry! n)
-          (/cmd-1 "delete" 'n help)      (whole-project-num "delete" n (fn [n] (delete-project n (machine-name))))
-          (/cmd-1 "show" 'n help)        (whole-project-num "show" n (fn [n] (show-project! n (machine-name))))
-          (/cmd-1 "show-id" 'n help)     (whole-project-num "show-id" n (fn [n] (show-project-id! n (machine-name))))
-          (/cmd-1 "mark-read" 'n help)   (whole-project-num "mark as read" n (fn [n] (newness/mark-read! (machine-name) n)))
-          (/cmd-1 "mark-unread" 'n help) (whole-project-num "mark as unread" n (fn [n] (newness/mark-unread! (machine-name) n)))
+          (/cmd-1 "delete" 'n help)      (whole-registered-machine-num "delete" n (fn [n] (delete-registered-machine n (machine-name))))
+          (/cmd-1 "show" 'n help)        (whole-registered-machine-num "show" n (fn [n] (show-registered-machine! n (machine-name))))
+          (/cmd-1 "show-id" 'n help)     (whole-registered-machine-num "show-id" n (fn [n] (show-registered-machine-id! n (machine-name))))
+          (/cmd-1 "mark-read" 'n help)   (whole-registered-machine-num "mark as read" n (fn [n] (newness/mark-read! (machine-name) n)))
+          (/cmd-1 "mark-unread" 'n help) (whole-registered-machine-num "mark as unread" n (fn [n] (newness/mark-unread! (machine-name) n)))
           (/cmd-0 "all-read" help)       (mark-all-read! (machine-name))
           (/cmd-help)                    (put-str! help)
           (/cons 'cmd _)                 (cmd-parse-failure (error/unknown-command cmd))
diff --git a/rad/monadic/items.rad b/rad/monadic/items.rad
index df13ba76a..ea9b8a25d 100644
--- a/rad/monadic/items.rad
+++ b/rad/monadic/items.rad
@@ -44,25 +44,25 @@
 (def item-title
   (fn [item-flag]
     (match item-flag
-      :issue    "title"
-      :patch    "commit"
-      :project  "project name")))
+      :issue              "title"
+      :patch              "commit"
+      :registered-machine "Radicle machine name")))
 
 (def pretty-table-header
   (fn [item-flag]
     (def title (item-title item-flag))
     (match item-flag
-    :project  (string-append
-                (wrap-cell "#" :number)
-                (wrap-cell title :title)
-                (wrap-cell "author" :author)
-                (wrap-cell "updated" :modified-at))
-    _         (string-append
-                (wrap-cell "state" :state)
-                (wrap-cell "#" :number)
-                (wrap-cell title :title)
-                (wrap-cell "author" :author)
-                (wrap-cell "updated" :modified-at)))))
+    :registered-machine  (string-append
+                           (wrap-cell "#" :number)
+                           (wrap-cell title :title)
+                           (wrap-cell "author" :author)
+                           (wrap-cell "updated" :modified-at))
+    _                    (string-append
+                           (wrap-cell "state" :state)
+                           (wrap-cell "#" :number)
+                           (wrap-cell title :title)
+                           (wrap-cell "author" :author)
+                           (wrap-cell "updated" :modified-at)))))
 
 (def pretty-modified-at
   (fn [i]
@@ -171,7 +171,7 @@
         :name tit
         :description desc
         :labels ls
-        :project-id id
+        :registered-machine-id id
         :username un
         :created-at c-a}
       (string-replace
@@ -180,7 +180,7 @@
        (string-append
         (pretty-headline i) "\n\n"
         "**Labels:** " (show ls) "\n\n"
-        "**Project ID:** " (show id) "\n\n"
+        "**Radicle machine ID:** " (show id) "\n\n"
         desc
         ))
       '{:patch p
@@ -196,9 +196,9 @@
 (def items-name
   (fn [item-flag]
     (match item-flag
-      :issue    "issues"
-      :patch    "patches"
-      :project  "projects")))
+      :issue               "issues"
+      :patch               "patches"
+      :registered-machine  "Radicle machines")))
 
 (def add-username
   (fn [d]
diff --git a/rad/monadic/registry-remote.rad b/rad/monadic/registry-remote.rad
index 7062ef762..0895c53e9 100644
--- a/rad/monadic/registry-remote.rad
+++ b/rad/monadic/registry-remote.rad
@@ -18,27 +18,27 @@
   "The name of this machine."
   "monadic/radicle/registry")
 
-(def projects
-  "Projects are stored in a dict in a ref, keyed by project-number."
+(def registered-machines
+  "Registered machines are stored in a dict in a ref, keyed by registered-machine-number."
   (ref {}))
 
-(def project-counter
-  "We use a stateful counter for giving projects numbers."
+(def registered-machine-counter
+  "We use a stateful counter for giving registered machine numbers."
   (make-counter))
 
 (def noncer (make-noncer))
 
 (def auth (make-simple-auth [:admin]))
 
-(def set-projects
-  "A helper to set stuff in the projects ref."
+(def set-registered-machines
+  "A helper to set stuff in the registered machines ref."
   (fn [l v]
-    (set-ref projects l v)))
+    (set-ref registered-machines l v)))
 
-(def over-projects
-  "A helper to modify stuff in the projects ref."
+(def over-registered-machines
+  "A helper to modify stuff in the registered machines ref."
   (fn [l f]
-    (over-ref projects l f)))
+    (over-ref registered-machines l f)))
 
 (def input-keys
   {:nonce      (noncer :validator)
@@ -67,43 +67,43 @@
    [(validator/keys input-keys)
     validator/signed]))
 
-(def validator/project-number
-  "A validator for numbers which refer to existing projects."
-  (validator/pred "Existing project number" (fn [n] (member? n (read-ref projects)))))
+(def validator/registered-machine-number
+  "A validator for numbers which refer to existing registered machines."
+  (validator/pred "Existing registered machine number" (fn [n] (member? n (read-ref registered-machines)))))
 
-(def validator/project-reference
-  "Refers to an existing project."
-  (validator/optional-keys {:project-number validator/project-number}))
+(def validator/registered-machine-reference
+  "Refers to an existing registered machine."
+  (validator/optional-keys {:registered-machine-number validator/registered-machine-number}))
 
-(def project-keys
-  {:name        (validator/string-of-max-length 100)
-   :description (validator/string-of-max-length 4000)
-   :labels      (validator/every (validator/string-of-max-length 80))
-   :project-id  (validator/string-of-max-length 80)})
+(def registered-machine-keys
+  {:name                   (validator/string-of-max-length 100)
+   :description            (validator/string-of-max-length 4000)
+   :labels                 (validator/every (validator/string-of-max-length 80))
+   :registered-machine-id  (validator/string-of-max-length 80)})
 
-(def validator/full-project (validator/keys project-keys))
+(def validator/full-registered-machine (validator/keys registered-machine-keys))
 
-(def validator/sub-project (validator/optional-keys project-keys))
+(def validator/sub-registered-machine (validator/optional-keys registered-machine-keys))
 
-(def validator/project-input
-  "A project should have all the required fields, be a signed input, etc."
+(def validator/registered-machine-input
+  "A registered machine should have all the required fields, be a signed input, etc."
   (validator/and
    [;; NOTE that we don't check `validator/input` at this point, because some of
     ;; the data is fixed before validation.
     validator/time-created
-    validator/full-project]))
+    validator/full-registered-machine]))
 
 (def validator/admin-or-author
   "Checks if the author of th request is either an admin or the author of the
-  project."
+  registered machine."
   (validator/or
     [(validator/pred
       "edit author == original author"
       (fn [c]
         (match c
-               {:project-number 'n
+               {:registered-machine-number 'n
                 :author 'a}
-               (eq? (view-ref projects (... [(@ n) (@ :author)]))
+               (eq? (view-ref registered-machines (... [(@ n) (@ :author)]))
                     a))))
     (auth [:allowed :admin])]))
 
@@ -112,73 +112,74 @@
   (fn [ks]
     (<> ks
         (<> (keys input-keys)
-            [:project-number :modified-at :author :signature]))))
+            [:registered-machine-number :modified-at :author :signature]))))
 
-(def validator/project-edit-input
-  "An input to edit a project."
+(def validator/registered-machine-edit-input
+  "An input to edit a registered machine."
   (validator/and
    [validator/input
     validator/time-modified
-    validator/sub-project
-    validator/project-reference
+    validator/sub-registered-machine
+    validator/registered-machine-reference
     validator/admin-or-author
-    (validator/contains-only (edit-keys (keys project-keys)))]))
+    (validator/contains-only (edit-keys (keys registered-machine-keys)))]))
 
 (def strip-input
   "After an entity input has been processed/verified, we no longer need some of
   the fields."
   (fn [e]
-    (delete-many [:machine-id :signature :nonce :project-number] e)))
+    (delete-many [:machine-id :signature :nonce :registered-machine-number] e)))
 
-(def register-project
-  "Register a project from a dict, checking that it is valid and storing it in `projects`."
+(def register-machine
+  "Register a Radicle machine from a dict, checking that it is valid and storing
+  it in `registered-machines`."
   (fn [i]
     (validator/input i)
-    (validator/project-input i)
-    (def n (project-counter :next))
+    (validator/registered-machine-input i)
+    (def n (registered-machine-counter :next))
     (def i_
       (strip-input
        (<> i
            {:number   n})))
-    (set-projects (@ n) i_)
+    (set-registered-machines (@ n) i_)
     (noncer [:use (lookup :nonce i)])
     n))
 
-(def delete-project
-  "Deletes the project from the prejects ref."
+(def delete-registered-machine
+  "Deletes the registered machine from the registered machines ref."
   (fn [i]
     (validator/input i)
     (validator/admin-or-author i)
-    (modify-ref projects \(delete (lookup :project-number i) ?))))
+    (modify-ref registered-machines \(delete (lookup :registered-machine-number i) ?))))
 
 (def merge-new
   (fn [new]
     (fn [old]
       (<> old new))))
 
-(def edit-project
-  "Modify some of the attributes of a project."
+(def edit-registered-machine
+  "Modify some of the attributes of a registered machine."
   (fn [i]
-    (validator/project-edit-input i)
+    (validator/registered-machine-edit-input i)
     (def i_ (delete :author (strip-input i)))
-    (over-projects (@ (lookup :project-number i)) (merge-new i_))))
+    (over-registered-machines (@ (lookup :registered-machine-number i)) (merge-new i_))))
 
 ;; These are intended for clients to run locally with eval-in-machine
 
-(def list-projects
-  "List existing projects."
-  (fn [] (read-ref projects)))
+(def list-registered-machines
+  "List existing registered machines."
+  (fn [] (read-ref registered-machines)))
 
 ;; General logic
 
 (def commands
   "The set of allowed machine commands."
   (ref
-    {'register-project  register-project
-     'edit-project      edit-project
-     'delete-project    delete-project
-     'list-projects     list-projects
-     'add-admin         (add-admin auth)}))
+    {'register-machine             register-machine
+     'edit-registered-machine      edit-registered-machine
+     'delete-registered-machine    delete-registered-machine
+     'list-registered-machines     list-registered-machines
+     'add-admin                    (add-admin auth)}))
 
 (def tx
   (lock-machine-commands (auth [:allowed :admin])
diff --git a/rad/monadic/registry.rad b/rad/monadic/registry.rad
index 2b88091ec..f75713afd 100644
--- a/rad/monadic/registry.rad
+++ b/rad/monadic/registry.rad
@@ -24,8 +24,8 @@
     (machine/send-signed-command! id radicle-registry-machine-id 'add-admin {:key owner-keys})
     id))
 
-(def simple-project
-  "Register a project with no labels."
+(def simple-registered-machine
+  "Register a Radicle machine with no labels."
   (fn [i]
     (def t (now!))
     (<> {:labels      []
@@ -33,40 +33,40 @@
          :modified-at t}
         i)))
 
-(def register-project!
-  "Register a new remote project with the keys in `my-keys.rad`."
+(def register-machine!
+  "Register a new remote machine with the keys in `my-keys.rad`."
   (fn [machine i]
-    (machine/send-signed-command! machine radicle-registry-machine-id 'register-project i)))
+    (machine/send-signed-command! machine radicle-registry-machine-id 'register-machine i)))
 
-(def edit-project!
-  "Edit a remote project with the keys in `my-keys.rad`."
+(def edit-registered-machine!
+  "Edit a remote registered machine with the keys in `my-keys.rad`."
   (fn [machine i]
-    (machine/send-signed-command! machine radicle-registry-machine-id 'edit-project i)))
+    (machine/send-signed-command! machine radicle-registry-machine-id 'edit-registered-machine i)))
 
-(def delete-project!
-  "Delete a remote project with the keys in `my-keys.rad`."
+(def delete-registered-machine!
+  "Delete a remote registered machine with the keys in `my-keys.rad`."
   (fn [machine i]
-    (machine/send-signed-command! machine radicle-registry-machine-id 'delete-project i)))
+    (machine/send-signed-command! machine radicle-registry-machine-id 'delete-registered-machine i)))
 
-(def simple-register-project!
-  "Register a remote project with sensible defaults."
+(def simple-register-machine!
+  "Register a remote machine with sensible defaults."
   (fn [machine name desc id]
-    (register-project! machine (simple-project {:name name :description desc :project-id id}))))
+    (register-machine! machine (simple-registered-machine {:name name :description desc :registered-machine-id id}))))
 
-(def simple-edit-project!
+(def simple-edit-registered-machine!
   (fn [machine n i]
-    (edit-project! machine
-                 (<> {:project-number n
+    (edit-registered-machine! machine
+                 (<> {:registered-machine-number n
                       :modified-at (now!)}
                      i))))
 
-(def list-projects
-  "Return the full map of projects."
+(def list-registered-machines
+  "Return the full map of registered machines."
   (fn [machine]
-    (machine/query! machine '(list-projects))))
+    (machine/query! machine '(list-registered-machines))))
 
 (def short
-  "Short render of a project."
+  "Short render of a registered machine."
   (fn [i]
     (string-append
      (show (lookup :number i))
@@ -74,9 +74,9 @@
      (lookup :name i))))
 
 (def list-last
-  "Get the last `n` projects."
+  "Get the last `n` regsistered machines."
   (fn [machine n]
-    (def is (sort-by (fn [i] (- 0 (lookup :number i))) (values (list-projects machine))))
+    (def is (sort-by (fn [i] (- 0 (lookup :number i))) (values (list-registered-machines machine))))
     (take n is)))
 
 (test
@@ -87,13 +87,13 @@
       (def non-owner-keys (gen-key-pair! (default-ecc-curve)))
       (set-fake-keys! owner-keys)
       (def machine (create-registry-machine!))
-      (simple-register-project! machine "name0" "desc0" "123")
-      (simple-register-project! machine "name1" "desc1" "456")
+      (simple-register-machine! machine "name0" "desc0" "123")
+      (simple-register-machine! machine "name1" "desc1" "456")
       (set-fake-keys! non-owner-keys)
-      (simple-register-project! machine "will be deleted" "none" "111")
-      (delete-project! machine {:project-number 2})
-      (simple-register-project! machine "new" "new" "111")
-      (def is (list-projects machine))
+      (simple-register-machine! machine "will be deleted" "none" "111")
+      (delete-registered-machine! machine {:registered-machine-number 2})
+      (simple-register-machine! machine "new" "new" "111")
+      (def is (list-registered-machines machine))
       (set-fake-keys! owner-keys))
  ]
  [ (length (seq is)) ==> 3 ]
@@ -102,27 +102,27 @@
  [ (short (first (values is))) ==> "0: name0" ]
  [ (short (first (list-last machine 1))) ==> "3: new" ]
  ;; authorization
- ;; owner can change the project name
+ ;; owner can change the registered machine name
  [ (do
       (set-fake-keys! owner-keys)
       (catch 'validation-failure
-             (do (simple-edit-project! machine 3 {:name "New name"})
+             (do (simple-edit-registered-machine! machine 3 {:name "New name"})
                  :valid)
              (fn [_] :not-valid))) ==> :valid
  ]
- ;; author can change the project name
+ ;; author can change the registered machine name
  [ (do
       (set-fake-keys! non-owner-keys)
       (catch 'validation-failure
-             (do (simple-edit-project! machine 3 {:name "New name"})
+             (do (simple-edit-registered-machine! machine 3 {:name "New name"})
                  :valid)
              (fn [_] :not-valid))) ==> :valid
  ]
- ;; non-owner/non-author cannot change the project name
+ ;; non-owner/non-author cannot change the registered machine name
  [ (do
       (set-fake-keys! non-owner-keys)
       (catch 'validation-failure
-             (do (simple-edit-project! machine 0 {:name "New name"})
+             (do (simple-edit-registered-machine! machine 0 {:name "New name"})
                  :valid)
              (fn [_] :not-valid))) ==> :not-valid
  ]
diff --git a/rad/prelude/error-messages.rad b/rad/prelude/error-messages.rad
index da16831c5..b4ffe3c45 100644
--- a/rad/prelude/error-messages.rad
+++ b/rad/prelude/error-messages.rad
@@ -82,11 +82,11 @@
 
 (def uppercase-item
   (fn [item]
-    (lookup item {:issue "Issue" :patch "Patch" :project "Project"})))
+    (lookup item {:issue "Issue" :patch "Patch" :registered-machine "Radicle machine"})))
 
 (def lowercase-item
   (fn [item]
-    (lookup item {:issue "issue" :patch "patch" :project "project"})))
+    (lookup item {:issue "issue" :patch "patch" :registered-machine "Radicle machine"})))
 
 ;; rad project specific errors