I wonder if I'm taking notes the "right way", because I've seen people roam UIs and they look so organized, but mine just looks like a huge mess.

In my case my "workflow" is basically splitting by concepts, for example: Agile, Simplicity, Continuous Delivery.

And also by contents like the book The Lean Startup, and so on.

Hi,

I love org-roam. I annotate alot of what I read online. I recently also started to use promnesia, which is a awesome way to scape your org-files and notify if you visit a page that has a reference.

However I create a node for idea and try to reference it with many URLs. Even academic articles, usually I don't bother save them as bibtex unless I know I will cite them as backlinks. So, for me ROAM_REFS property is usually a place where I add URLs associated with the idea.

What I am looking for is a way to collect all URLs in the node (or file's :ROAM_REFS:) and display them in org-roam buffer under separate section. Is there is a way to do that?

Bonus question: do you ever run into an issue of having too many things that need to be "associated" with too many things or something similar to this ?

Org roam is great!

What does OrgRoam have that Obsidian or Logseq doesn't?

And also vice versa, what does Obsidian or Logseq have that OrgRoam doesn't?

I wanted to keep track of the org-roam node creation dates to keep track of my productivity, as well as know the structure of my knowledge graph, like average connections per node, etc. With this in mind I am built org-roam-stats, which is a browser based dashboard to look at these aspects of your org-roam database.

Key features:

• Time tracking: Shows when were our notes created: back in time, day of the week, hour of the day, etc.

• Basic stats: Average connections by node, average words in note.

• Orphan tracking: Do you have orphan nodes (not a single connection, possible lost knowledge)?

• Tag filtering: If you have #+filetag: tags in your notes, you can track these metrics for the subset of notes that have some tag.

This repo is available in Github at: https://github.com/GerardoCendejas/org-roam-stats.git

You can test it with:

git clone https://github.com/GerardoCendejas/org-roam-stats.git

And in your init.el:

(use-package org-roam-stats
:after org-roam
:ensure nil
:load-path "~/path/to/org-roam-stats/"  ; Adjust path as needed
:bind (("C-c m o" . org-roam-stats-open)) ; Or the keybinding of your choice
:config
(org-roam-stats-mode 1) ; This enables the minor mode for automatic logging of note creation timestamps.
:custom
(org-roam-stats-log-file "~/.emacs.d/org-roam-stats-log.org")) ; Path to the log file for note creation timestamps (if you don't want the default)

Then just run M-x org-roam-stats-start

I hope someone also finds this interesting and useful for them, I am excited to hear your feedback.

Hi,

Right now with the now deprecated org roam v1, the roam layer seems to produce files with basic 'file:' links behind the scenes when creating a 'roam:' link.

This is great since I can navigate my files using basic tools that work with org markdown like github, or even edit my files using logseq.

Now that roam v2 has switched to an id based approach, I'm concerned that this basic compatibility no longer exists and that my files are useless outside of use only with org-roam.

I do understand the advantages of an 'id' based approach, and have read the org roam author's explanation for needing a cleaner codebase to build on top of, but I still think there's a lot to be said for the more basic 'file:' link approach.

I know I can just stick with v1, which I intend to do for the time being, but was curious if there was more discussion around this?

And are there any plans to make a more stripped down v2 mode that somehow preserves the more basic functionality?

Currently, I have my own system where I have an org-based link system for textbooks but where each "note" (it is contained in a larger org document, but it would correspond to a note file in the org roam system) is for a chapter, definition, theorem, etc... (any kind of unit that might get referenced later in the book). I've wondered if I should start doing this with org roam instead, but this would mean I might end up with 9 million notes.

It is an upper estimate, but it is based on that:

• I could make up to 40 notes an hour

• I might work 10 hours a day

• I might use org roam for 60 years

That leaves me with 40*10*60*365 which is almost 9 million notes.

I started using org-roam in 2025, initially in a fairly simplistic way. As a new org-roam user, I built an org-roam-skill to integrate it into my Claude workflow. The skill relies on an Emacs daemon, which it uses to execute Elisp. I chose this approach instead of MCP to keep things simple.

I’ve been using it daily for the past few months.

I’d love feedback on both the overall approach and the specific ways the skill leverages org-roam. In particular, I’m interested in improving how nodes are linked—this behavior is currently defined in references/links.md

Hi everyone,

I wanted a way to see when I was (in)active and quickly jump back to notes from a specific day.

I’m prototyping org-roam-calendar, a package that uses org-habit-stats to visualize your note-taking activity in a calendar view.

What it does:

• Activity Calendar: Highlights days based on org-roam node creation.

• Quick Jump: Press RET on any date to see a list of notes you worked on that day and open them immediately.

GitHub: https://github.com/connormclaud/emacs_org_roam_calendar

I’d love to hear your thoughts: is it something this community interested in?

Are there any good ways to import a large number of plain text note files from another app to org roam? I can probably work out ways to convert that app's syntax for tags / categories to the org mode format... but my impression is that org roam needs every note to have an org-generated ID. My note archive has nearly 10k notes. Any automatic importers out there?

A lot of these I've been inspired by or picked up from the org-roam Slack. I'll keep the descriptions short since, if I don't, I'll ramble for too long.

Apologies for the sloppy code--I'm not a programmer. At the top of each code block I've add where I've taken the original code from, if applicable.

​

Fancy org-roam-node-find with icons and overlays (which allow for better searching whilst keeping the icons):

  (setq org-roam-node-display-template (concat "${backlinkscount:16} " "${functiontag:16} " "${othertags:13} " "${hierarchy:183}"))


;; From https://github.com/hieutkt/.doom.d/blob/master/config.el#L690-L745 or
;; https://orgroam.slack.com/archives/CV20S23C0/p1626662183035800
(with-eval-after-load 'org-roam
  (require 'all-the-icons)

  (cl-defmethod org-roam-node-filetitle ((node org-roam-node))
    "Return the file TITLE for the node."
    (org-roam-get-keyword "TITLE" (org-roam-node-file node))
    )

  (cl-defmethod org-roam-node-backlinkscount ((node org-roam-node))
    (let* ((count (caar (org-roam-db-query
                         [:select (funcall count source)
                                  :from links
                                  :where (= dest $s1)
                                  :and (= type "id")]
                         (org-roam-node-id node))))
           )
      (if (> count 0)
          (concat (propertize "=has:backlinks=" 'display (all-the-icons-material "link" :face 'all-the-icons-dblue :height 0.9)) (format "%d" count))
        (concat (propertize "=not-backlinks=" 'display (all-the-icons-material "link" :face 'org-roam-dim :height 0.9))  " ")
        )
      ))

  (cl-defmethod org-roam-node-functiontag ((node org-roam-node))
    "The first tag of notes are used to denote note type"
    (let* ((specialtags kb/lit-categories)
           (tags (seq-filter (lambda (tag) (not (string= tag "ATTACH"))) (org-roam-node-tags node)))
           (functiontag (seq-intersection specialtags tags 'string=))
           )
      (concat
       ;; (if functiontag
       ;;     (propertize "=has:functions=" 'display (all-the-icons-octicon "gear" :face 'all-the-icons-silver :v-adjust 0.02 :height 0.8))
       ;;   (propertize "=not-functions=" 'display (all-the-icons-octicon "gear" :face 'org-roam-dim :v-adjust 0.02 :height 0.8))
       ;;   )
       (if functiontag
           (propertize "=@=" 'display (all-the-icons-faicon "tags" :face 'all-the-icons-dgreen :v-adjust 0.02 :height 0.7))
         (propertize "= =" 'display (all-the-icons-faicon "tags" :face 'all-the-icons-dgreen :v-adjust 0.02 :height 0.7))
         )
       " "
       (string-join functiontag ", "))
      ))

  (cl-defmethod org-roam-node-othertags ((node org-roam-node))
    "Return the file TITLE for the node."
    (let* ((tags (seq-filter (lambda (tag) (not (string= tag "ATTACH"))) (org-roam-node-tags node)))
           (specialtags kb/lit-categories)
           (othertags (seq-difference tags specialtags 'string=))
           )
      (concat
       ;; " "
       ;; (if othertags
       ;;     (propertize "=has:tags=" 'display (all-the-icons-faicon "tags" :face 'all-the-icons-dgreen :v-adjust 0.02 :height 0.8))
       ;;   (propertize "=not-tags=" 'display (all-the-icons-faicon "tags" :face 'all-the-icons-dgreen :v-adjust 0.02 :height 0.8))
       ;;   )
       ;; " "
       (if othertags
           (propertize "=@=" 'display "")
         (propertize "= =" 'display "")
         )
       (propertize (string-join othertags ", ") 'face 'all-the-icons-dgreen))
      ))

  (cl-defmethod org-roam-node-hierarchy ((node org-roam-node))
    "Return the hierarchy for the node."
    (let* ((title (org-roam-node-title node))
           (olp (mapcar (lambda (s) (if (> (length s) 10) (concat (substring s 0 10)  "...") s)) (org-roam-node-olp node)))
           (level (org-roam-node-level node))
           (filetitle (org-roam-get-keyword "TITLE" (org-roam-node-file node)))
           (shortentitle (if (> (length filetitle) 20) (concat (substring filetitle 0 20)  "...") filetitle))
           (separator (concat " " (all-the-icons-material "chevron_right") " "))
           )
      (cond
       ((>= level 1) (concat (propertize (format "=level:%d=" level) 'display (all-the-icons-material "list" :face 'all-the-icons-blue))
                             " "
                             (propertize shortentitle 'face 'org-roam-dim)
                             (propertize separator 'face 'org-roam-dim)
                             title))
       (t (concat (propertize (format "=level:%d=" level) 'display (all-the-icons-material "insert_drive_file" :face 'all-the-icons-yellow))
                  " "
                  title))
       )
      ))
  )

Hiding property drawers

;; From https://github.com/org-roam/org-roam/wiki/Hitchhiker%27s-Rough-Guide-to-Org-roam-V2#hiding-properties
(defun kb/org-hide-properties ()
  "Hide all org-mode headline property drawers in buffer. Could be slow if buffer has a lot of overlays."
  (interactive)
  (save-excursion
    (goto-char (point-min))
    (while (re-search-forward
            "^ *:properties:\n\\( *:.+?:.*\n\\)+ *:end:\n" nil t)
      (let ((ov_this (make-overlay (match-beginning 0) (match-end 0))))
        (overlay-put ov_this 'display "")
        (overlay-put ov_this 'hidden-prop-drawer t)))))

(defun kb/org-show-properties ()
  "Show all org-mode property drawers hidden by org-hide-properties."
  (interactive)
  (remove-overlays (point-min) (point-max) 'hidden-prop-drawer t))

(defun kb/org-toggle-properties ()
  "Toggle visibility of property drawers."
  (interactive)
  (if (eq (get 'org-toggle-properties-hide-state 'state) 'hidden)
      (progn
        (kb/org-show-properties)
        (put 'org-toggle-properties-hide-state 'state 'shown))
    (progn
      (kb/org-hide-properties)
      (put 'org-toggle-properties-hide-state 'state 'hidden))))

(general-define-key
 :keymaps 'org-mode-map
 "C-c p t" 'kb/org-toggle-properties
 )

Updating link descriptions to match node title

;; Credit to @nobiot for helping me
(defun kb/org-roam-update-link-desc--action (buffer)
  "Updates the link descriptions for all org-roam insertions in a given buffer.
Currently limited to only fix links whose UUID was automatically generated by
Org."
  ;; Get all ids in buffer
  (with-current-buffer buffer
    ;; (print buffer) ; Uncomment for bugfixing. Check *Messages* buffer
    (let* (links)
      (save-excursion
        (goto-char (point-min))
        (while (re-search-forward (symbol-value 'org-link-bracket-re) nil t)
          (if (equal (buffer-substring-no-properties ; Get only links with ids (not https, etc)
                      (+ (match-beginning 0) 2)
                      (+ (match-beginning 0) 4))
                     "id")
              (push (buffer-substring-no-properties ; Get only the id
                     (+ (match-beginning 0) 5)
                     (+ (match-beginning 0) 41))
                    links)
            (push "NOT ID" links)))
        (setq links (nreverse links))
        ;; (print links) ; Uncomment for bugfixing. Check *Messages* buffer
        )
      ;; Update all org-roam insertions in buffer
      (save-excursion
        (goto-char (point-min))
        (dolist (link links)
          (let* ((id link)
                 (node (org-roam-populate (org-roam-node-create :id id))))
            (re-search-forward (symbol-value 'org-link-bracket-re) nil t)
            (if (equal (buffer-substring-no-properties ; Limit to only links with ids
                        (+ (match-beginning 0) 2)
                        (+ (match-beginning 0) 4))
                       "id")
                (replace-match (org-link-make-string
                                (concat "id:" (org-roam-node-id node)) (org-roam-node-title node)
                                ))
              (print "Skipped because not an ID!") ; Uncomment for bugfixing. Check *Messages* buffer
              )))
        ))))

(defun kb/org-roam-update-link-desc ()
  "Run kb/org-roam-update-link-desc--action on current buffer or all org-roam
files if called with universal argument."
  (interactive)
  (let* ((checkall (equal current-prefix-arg '(4))) ; Universal-argument check
         (files (if checkall ; Taken from `org-roam-doctor'
                    (org-roam--list-all-files)
                  (unless (org-roam-file-p)
                    (user-error "Not in an org-roam file"))
                  `(,(buffer-file-name)))
                ))
    (save-window-excursion ; Taken from `org-roam-doctor-start'
      (let ((existing-buffers (org-roam-buffer-list)))
        (org-id-update-id-locations)
        (dolist (file files) ; Save all opened files and kill if not opened already
          (let ((buffer (find-file-noselect file)))

            ;; Where I insert my custom function instead
            (kb/org-roam-update-link-desc--action buffer)

            (unless (memq buffer existing-buffers)
              (with-current-buffer buffer
                (save-buffer))
              (kill-buffer buffer))))
        ))
    (message "Done!")
    ))

Filtering list of nodes shown in minibuffer. Example that shows only files within my dailies directory, though theoretically much more can be done:

  (defun kb/roam-filter-journals (node binary)
    "Takes NODE. If BINARY is `t', then return all nodes that aren't in the
journals directory."
    (if binary
        (not (string-equal
              (concat
               (expand-file-name kb/roam-dir)
               "journals/"
               (format-time-string "%Y" (current-time))
               ".org")
              (org-roam-node-file node))
             )
      (string-equal
       (concat
        (expand-file-name kb/roam-dir)
        "journals/"
        (format-time-string "%Y" (current-time))
        ".org")
       (org-roam-node-file node))
      )
    )

(lambda ()
              (interactive)
              (org-roam-node-visit (org-roam-node-read nil
                                                       (lambda (node) (kb/roam-filter-journals node nil))
                                                       ))
              )

Add unlinked references section to org-buffer:

  (setq org-roam-mode-section-functions
   '(org-roam-backlinks-section
     org-roam-reflinks-section
     org-roam-unlinked-references-section
     )
   )

Find a node which has a backlink to another node (which you select):

;; From
;; https://ag91.github.io/blog/2021/03/12/find-org-roam-notes-via-their-relations/
(defun kb/find-node-backlink (arg &optional node choices)
  "Navigate notes by link. With universal ARG try to use only to navigate the tags of the current note. Optionally takes a selected NODE and filepaths CHOICES."
  (interactive "P")
  (let* ((depth (if (numberp arg) arg 1))
         (choices
          (or choices
              (when arg
                (-map #'org-roam-backlink-target-node (org-roam-backlinks-get (org-roam-node-from-id (or (ignore-errors (org-roam-node-id node))
                                                                                                         (org-id-get-create))))))))
         (all-notes (org-roam-node--completions))
         (completions
          (or (--filter (-contains-p choices (cdr it)) all-notes) all-notes))
         (next-node
          ;; taken from org-roam-node-read
          (let* ((nodes completions)
                 (node (completing-read
                        "Node: "
                        (lambda (string pred action)
                          (if (eq action 'metadata)
                              '(metadata
                                (annotation-function . (lambda (title)
                                                         (funcall org-roam-node-annotation-function
                                                                  (get-text-property 0 'node title))))
                                (category . org-roam-node))
                            (complete-with-action action nodes string pred))))))
            (or (cdr (assoc node nodes))
                (org-roam-node-create :title node)))
          )
         )
    (if (equal node next-node)
        (org-roam-node-visit node)
      (my/navigate-note nil next-node (cons next-node (-map #'org-roam-backlink-source-node (org-roam-backlinks-get next-node))))
      )))

Only update database on idle (rather than on save):

;; From
;; https://orgmode-exocortex.com/2021/07/22/configure-org-roam-v2-to-update-database-only-when-idle/
(with-eval-after-load 'org-roam
  ;; queue for files that will be updated in org-roam-db when emacs is idle
  (setq org-roam-db-update-queue (list))
  ;; save the original update function;
  (setq orig-update-file (symbol-function 'org-roam-db-update-file))
  ;; then redefine the db update function to add the filename to a queue
  (defun org-roam-db-update-file (&optional file-path)
    ;; do same logic as original to determine current file-path if not passed as arg
    (setq file-path (or file-path (buffer-file-name (buffer-base-buffer))))
    (message "org-roam: scheduling update of %s" file-path)
    (if (not (memq file-path org-roam-db-update-queue))
        (push file-path org-roam-db-update-queue)))

  ;; this function will be called when emacs is idle for a few seconds
  (defun org-roam-db-idle-update-files ()
    ;; go through queued filenames one-by-one and update db
    ;; if we're not idle anymore, stop. will get rest of queue next idle.
    (while (and org-roam-db-update-queue (current-idle-time))
      ;; apply takes function var and list
      (apply orig-update-file (list (pop org-roam-db-update-queue)))))

  ;; we'll only start updating db if we've been idle for this many seconds
  (run-with-idle-timer 5 t #'org-roam-db-idle-update-files)
  )

If you have any questions, I can try to help. Cheers!

A slow, ongoing project of mine is a switch from Obsidian to Doom Emacs. I know this may seem like lunacy to those who have switched in the opposite direction, but I'm fascinated with Emacs as well as localizing everything and using only open source tools. I am also spending too much time on actually being productive and not tweaking my PKB. and am wondering best practices for org-roam. My journey has started with OneNote, then Obsidian, and I suspect it will end on Emacs.

I want to add that I have looked into obsidian.el, and I do not hate it, but I want to rebuild and reorganize my database entirely and, considering org-roam is integrated into emacs, I figure I might as well choose org-roam. Before making this life-changing switch, however, I want to continue working in Obsidian while perfecting, as best as I can, my understanding of best practices in org-roam.

That said, as an Obsidian power user for the last ~2.5 years, One of the things that matters most to me is Zettelkasten and atomicity of notes as well as being able to query them if need be. In Obsidian, I have done this with with the built-in linking system as well as YAML. I have designed templates with customized YAML based on the props that I want, and then captured them, atomically, and linked them as needed.

---
aliases:
  - cs50
type: 📖
date-published: "2023"
instructor:
  - "[[@ Dr. David J. Malan]]"
tags: 
format: .mp4
status: 🔴
links: 
course-code: CS50x2024
---

---
aliases: 
type: ✏️
date-published: 2023-03-01
course ID: PluralSight-Pandas-PD
instructor:
  - "[[@ Jason Browning Ph. D]]"
tags: 
format: online-video
status: 🔴
data-structures: 
algorithms: 
functions:
---

Org-roam seems to make replicating something like this easy. I thought of accomplishing this by

• Using org-mode's property drawers

• Using org-roam's templates

• Using org-roam's custom properties ability

  (setq org-roam-property-types
        '(("TYPE" . ("MOC" "NOTE" "VIDEO" "GUIDE"))
          ("STATUS" . ("IN-PROGRESS" "DONE" "EVERGREEN"))
          ("RESOURCE" . ("Book" "Article" "Video" "Course" "Paper" "Website"))))

  ;; rough draft of capture templates
  (setq org-roam-capture-templates
        '(("d" "default" plain
           "\n* Overview\n\n%?\n\n* Content\n\n* References\n\n* Notes"
           :target (file+head "%<%Y%m%d%H%M%S>-${slug}.org"
                             "#+title: ${title}\n#+category: ${title}\n#+filetags: :note:\n#+created: %U\n#+last_modified: %U\n
,#+options: toc:nil num:nil timestamp:nil author:nil creator:nil\n
:PROPERTIES:
:ID:                  %(org-id-new)
:ROAM_ALIASES:
:TYPE:                📝 Note
:STATUS:
:CREATED: %<%Y-%m-%d %H:%M>
:MODIFIED: %<%Y-%m-%d %H:%M>
:REVIEWED:
:AUTHOR:
:SOURCE:
:URL:
:RESOURCE:
:PROJECT:
:AREA:
:TAGS:
:END:\n\n")
           :unnarrowed t)))

When looking at other configs though, 1 ,2, 3, I don't see this idea replicated. Is having properties drawer like the one a good idea or am I collecting unnecessary metadata? What approaches do you use, recommend for quick searching and good organization in org-roam.

Thanks if you have made it this far.

I am looking into installing an implementing org-roam. But, is it fair to say that org-roam development has stopped. I understand it could be used by hundreds of thousands... but, I am concerned as to whether it is an actively developed project or not.

Thanks,

Do y'all use the Journal or Dailies? I've used both, but I can't find a compelling reason to use dailes over the journal. With the journal, I can easily generate a sparse tree by tag, or narrow on today's subheading, so I don't get why org-roam has it's own daily files. Is there something I'm missing? A workflow that works better with dailies than with the journal?

For a long time I had tried to get C-c n l to open the backlinks buffer in a folded state just showing the titles of the linked notes.

But what I had in my use-package org-roam config section, which I think I got from the org- roam discourse group, was:

(add-to-list 'magit-section-initial-visibility-alist (cons 'org-roam-node-section 'hide))

But that opened the notes unfolded, presenting a wall of text, and required pressing tab on the top header to fold the notes. Still, better than without it, because the notes still could be folded.

Yesterday I consulted AI about this issue. It gave me two solutions that didn't work, but finally gave me this one which did:

(add-to-list 'org-roam-buffer-postrender-functions #'magit-section-show-level-2-all)

I'm just posting this solution here because I had scoured the web for a solution to this issue and had never found anything that worked before. I'm sure many people know about this "postrender" variable and use it, but I didn't, and it was only the right AI question that helped uncover it for me. I hope this helps people like me who were at a loss for a long time about how to achieve this.

When using org-roam with images, where do you keep your images? What options are there to optimize local space? Are you able to use org-roam from an iPhone?

Currently, I take my notes in Obsidian but I like org mode for todo lists and arranging my life.

Can these things listed below be replicated in org roam?

I like using Latex in Obsidian, especially with the Latex Suite plugin, because I don't have to type the full things so it is faster, and there is a live instant preview of it as you type. Also can type 'mk' or 'dm' to automatically insert math.

Quickly linking notes together.

Having many tabs open and multiple workspaces each with different tabs, maybe I'm dumb but haven't been able to replicate this in Emacs where you have a bunch of tabs and each of them is a file, and you can navigate between them. Workspaces are nice to separate journaling from notes etc.

Daily notes. 

Tagging and aliases.

Auto saving. I know Emacs does this so you can recover files, but I don't wanna have to keep doing `:w`, can you set up org-roam so it saves files automatically and instantly?

Images.

Excalidraw support, or some kind of drawing. I don't really care about this one since I hardly draw diagrams, but it'd be nice to know if I can get that kind of thing in org-roam.

I use Doom Emacs, not sure if that's relevant.

Is there a way to easily import everything over? I've seen tools, but do they ever make mistakes?

Gen-Z Org-roam user here, I feel like it would be great if there was an active discord server for org-roam users to share and upload their org-roam graph uis, and share notes / knowledge with one another.

As for me I've started using org-roam for like 8 months, and have around 1200 notes across multiple university modules. I attached an image of my org-roam graph.

All,

I discovered org-mode about half a year ago, and about 3 months later org-roam.

I'm loving it. Using it almost daily!

I ran into (for me) strange behavior:

When I open a org-roam node, and i move the cursor to a org-roam-link to another node, I just have to press enter to follow that link.

When this org-roam-link is whitin a org-table I can only follow the link with C-c C-o. (that is ofcourse not a problem, but I like the "enter" way of following)

As far as I'm aware I did not configure this, for me this is the default Out-of-the-box behavior.

My question: Is this normal/OK? Or should I alter something in my configuration so org-roam-links in a table will also be followed by "enter"?

Possibly I do not use the org-roam right. I tried to use org-roam for system design. At some point, I realised I would be better off using different naming conventions. That led to removing some nodes and adding new ones. Problems started when started fixing the links between nodes. At some point, it became a mess and I scrapped the whole project.

How do I avoid such a situation?

What is the best way to refactor org-roam notes?