GNU ELPA - bufferlo

The first three of these commands accept multiple selected bookmarks. This can be made easier by leveraging Emacs completion packages such as orderless which adds regexp matching. This is even more convenient in combination with a package like vertico.

• bufferlo-bookmarks-load-interactive (alias bufferlo-bms-load): Load one or more stored saved bufferlo frame or tab bookmarks.
• bufferlo-bookmarks-load: load stored bufferlo bookmarks that match your load predicates, or load all when using a prefix argument or when you call the function using passing t as its sole argument. Bookmarks already loaded are ignored.
• bufferlo-bookmarks-save-interactive (alias bufferlo-bms-save): Save one or more currently active bufferlo frame or tab bookmarks.
• bufferlo-bookmarks-save: save active bufferlo bookmarks that match your save predicates, or save all when using a prefix argument or when you call the function using passing t as its sole argument.
• bufferlo-bookmarks-close-interactive (alias bufferlo-bms-close): Close one or more currently active bufferlo frame or tab bookmarks, killing the buffers from each local buffer list. You will not be prompted to save bookmarks or further confirm buffer kills except where their content requires saving or contain active processes; e.g., *shell* buffers.
• bufferlo-bookmarks-close: Close all active bufferlo frame and tab bookmarks and kill their buffers. You will be prompted to save bookmarks using filter predicates or all unless a prefix argument is specified to inhibit the prompt and rely on your default policy.
• bufferlo-bookmark-raise (alias bufferlo-bm-raise): Select the frame and/or frame/tab of the chosen active bookmark. Note: If you have duplicate active bookmarks, the first one found wins.

• bufferlo-clear-active-bookmarks Clear all active bufferlo frame and tab bookmarks. This leaves frames and tabs intact, content untouched, and does not impact stored bookmarks. You will be prompted to confirm clearing (which cannot be undone) unless a prefix argument is specified to inhibit the prompt.

  This is useful when you have accumulated a complex working set of frames, tabs, buffers and want to save new bookmarks without disturbing existing bookmarks, or where auto-saving is enabled and you want to avoid overwriting stored bookmarks, perhaps with transient work.

• bufferlo-maybe-clear-active-bookmark Clear the current frame and/or tab bufferlo bookmark. By default, this clears the active bookmark name only if there is another active bufferlo bookmark with the same name. Use a prefix argument or call the function with t to force clear the bookmark even if it is currently unique.

  This is useful if an active bookmark has been loaded more than once, and especially if you use the auto-save feature and want to ensure that only one bookmark is active.

• bookmark-bmenu-list: Typically bound to C-x r l, this loads the standard Emacs bookmark menu to select a bookmark and manage the bookmark list including non-bufferlo bookmarks. Bufferlo frame bookmarks are identified as "B-Frame", tab bookmarks as "B-Tab", and bookmark sets as "B-Set".
• bookmark-rename: Invoke this command to rename a bookmark. This command will refuse to rename an active bufferlo bookmark (close or clear it and then rename). This function is also available via bookmark-bmenu-list.
• bookmark-delete: Invoke this command to delete a bookmark. This command will refuse to delete an active bufferlo bookmark (close or clear it and then delete). This function is also available via bookmark-bmenu-list.

Note: Renaming or deleting a bufferlo tab or frame bookmark does not rename or delete references to those bookmarks within bookmark sets.

• bufferlo-bookmark-frame-save (alias bufferlo-bm-frame-save): Save a bookmark for the current frame under a new name or pick an existing name to reuse.
• bufferlo-bookmark-frame-save-current (alias bufferlo-bm-frame-save-curr): Update the existing bookmark for the current frame.
• bufferlo-bookmark-frame-load (alias bufferlo-bm-frame-load): Load a frame bookmark. This will overwrite your current frame content (no buffers are killed). Use a prefix argument to inhibit creating a new frame.
• bufferlo-bookmark-frame-load-current (alias bufferlo-bm-frame-load-curr): Reload the existing bookmark for the current frame. This will overwrite your current frame content (no buffers are killed).
• bufferlo-bookmark-frame-load-merge (alias bufferlo-bm-frame-load-merge): Load a frame bookmark, but instead of creating a new frame or overwriting the current frame content, this adds the loaded tabs into the current frame.

• bufferlo-bookmark-tab-save (alias bufferlo-bm-tab-save): Save a bookmark for the current tab under a new name or pick an existing name to reuse.
• bufferlo-bookmark-tab-save-current (alias bufferlo-bm-tab-save-curr): Update the existing bookmark for the current tab (no buffers are killed).
• bufferlo-bookmark-tab-load (alias bufferlo-bm-tab-load): Load a tab bookmark. This will overwrite your current tab content (no buffers are killed). Use a prefix argument to inhibit creating a new tab.
• bufferlo-bookmark-tab-load-current (alias bufferlo-bm-tab-load-curr): Reload the existing bookmark for the current tab. This will overwrite your current tab content (no buffers are killed).

• bufferlo-set-save-interactive (alias bufferlo-set-save): Save a bufferlo bookmark set for the specified active bookmarks. Frame bookmark names are stored along with their geometry for optional restoration. Tab bookmark names are grouped based on their shared frames along with each frame's geometry.
• bufferlo-set-save-current-interactive (alias bufferlo-set-save-curr): Update the content of all active constituent bookmarks in selected bookmark sets.
• bufferlo-set-load-interactive (alias bufferlo-set-load): Prompt to load bufferlo set bookmarks. This will restore each set's constituent frame and tab bookmarks along with the tab bookmarks' shared frames. Frame geometry is optionally restored.
• bufferlo-set-clear-interactive (alias bufferlo-set-clear): Clear the specified bookmark sets. This has the effect of leaving the set's constituent frame and tab bookmarks in place while indicating that the bookmark sets are no longer active.
• bufferlo-set-close-interactive (alias bufferlo-set-close): Close the specified bookmark sets. This closes their constituent bookmarks and kills their buffers.
• bufferlo-set-list-interactive (alias bufferlo-set-list): List the constituent bookmarks of the selected active sets in a special-mode buffer and pop to it. The display shows each bookmark's name, its type, the frame it's currently on, and, if a tab bookmark, its tab number. Typing <RET> or clicking mouse-1 will raise the selected bookmark. Type "q" to quit.

Notes:

• To curate a saved bookmark set, invoke bufferlo-set-save-interactive and save a new set of active bookmarks, replacing the existing bookmark set.
• Bookmark sets are unaware of constituent frame and tab bookmark renames or deletes.
• Bookmark sets are Emacs bookmarks and can be deleted or renamed using Emacs bookmark commands; e.g., via bookmark-bmenu-list.
• While bookmark sets can be auto loaded, just as individual frame and tab bookmarks can be, bookmark sets cannot themselves be auto-saved. Constituent bookmarks are saved individually based on your auto-save predicates.

These do-what-I-mean aka DWIM commands are conveniences that detect an active frame or tab bookmark avoiding the need to to specify the frame or tab variants of the equivalent commands.

Note: Bufferlo DWIM commands prioritize frame bookmarks over tab bookmarks should both exist.

• bufferlo-bookmark-save-curr (alias bufferlo-bm-save): Save the current frame or tab bookmark. This does not prompt to save a new bookmark if no bookmark is established.
• bufferlo-bookmark-load-curr (alias bufferlo-bm-load): Reload the current frame or tab bookmark. This does not prompt to load a new bookmark if no bookmark is established.
• bufferlo-bookmark-close-curr (alias bufferlo-bm-close): Close current frame or tab bookmark and kill its buffers.

To control bufferlo confirmation prompts when killing local or orphan buffers:

(setq bufferlo-kill-buffers-prompt t) ; default nil

To control bufferlo behavior when closing frame or tab bookmarks and killing their local modified buffers or process buffers such as shell-mode or eshell-mode:

(setq bufferlo-kill-modified-buffers-policy nil) ; use normal Emacs prompting behavior
(setq bufferlo-kill-modified-buffers-policy 'retain-modified) ; kill just unmodified
(setq bufferlo-kill-modified-buffers-policy 'retain-modified-kill-without-file-name) ; kill unmodified and buffers without files
(setq bufferlo-kill-modified-buffers-policy 'kill-modified) ; kill local buffers without prompting; the default

You can configure bufferlo to automatically save some or all bookmarks based on an interval timer and/or at Emacs exit. Similarly, you can configure bufferlo to automatically load some or all bookmarks at Emacs startup.

To set the automatic save timer, set the number of whole integer seconds between saves that you prefer, or 0, the default, to disable the timer:

(setq bufferlo-bookmarks-auto-save-interval 120) ; do this in advance of enabling `bufferlo-mode'
(setopt bufferlo-bookmarks-auto-save-interval 120) ; or use setopt, to invoke the custom setter

By default, bufferlo will save all active bookmarks. To select the subset of bookmarks you want to save, write one or more predicate tests that accept a bookmark name as its argument; it should return t to indicate to save the bookmark, or nil otherwise.

Example auto-save predicate:

(defun my/bufferlo-bookmarks-save-p (bookmark-name)
  "Auto save bufferlo bookmarks that contain \"=as\" for autosave."
  (string-match-p (rx "=as") bookmark-name))
(setq bufferlo-bookmarks-save-predicate-functions nil) ; clear the default #'bufferlo-bookmarks-save-all-p
(add-hook 'bufferlo-bookmarks-save-predicate-functions #'my/bufferlo-bookmarks-save-p)

You can control messages produced when bufferlo saves bookmarks:

(setq bufferlo-bookmarks-auto-save-messages nil) ; inhibit messages (default)
(setq bufferlo-bookmarks-auto-save-messages t) ; messages when saving and when there are no bookmarks to save
(setq bufferlo-bookmarks-auto-save-messages 'saved) ; message only when bookmarks are saved
(setq bufferlo-bookmarks-auto-save-messages 'notsaved) ; message only when there are no bookmarks to save

To save your bufferlo bookmarks when frames and tabs are closed:

(setq bufferlo-bookmark-frame-save-on-delete 'if-current)
(setq bufferlo-bookmark-tab-save-on-close 'if-current)
;; See the variables' documentation for more options

To save your bufferlo bookmarks at Emacs exit (set in advance of enabling bufferlo-mode):

(setq bufferlo-bookmarks-save-at-emacs-exit 'nosave) ; inhibit saving at exit (default)
(setq bufferlo-bookmarks-save-at-emacs-exit 'pred) ; save active bookmark names that match your predicates
(setq bufferlo-bookmarks-save-at-emacs-exit 'all) ; save all active bookmarks

Workflow tip: If you would like to be able to restore a bookmark's original state and still benefit from auto-saving its current state, simply save two copies. The first one with a base name; e.g., "bufferlo", and the second, which you should save immediately after the first, called; e.g., "bufferlo=as". You can restore "bufferlo" and get back to your original any time while the "=as" bookmark will save your context as you work. Switch between them as you see fit.

To automatically load some or all bufferlo bookmarks at Emacs startup time (bufferlo uses window-setup-hook to load bookmarks after your init.el has completed to maximize the chances for successful loading):

(setq bufferlo-bookmarks-load-at-emacs-startup 'noload) ; inhibit loading at startup (default)
(setq bufferlo-bookmarks-load-at-emacs-startup 'pred) ; load bookmark names that match your predicates
(setq bufferlo-bookmarks-load-at-emacs-startup 'all) ; load all bufferlo bookmarks

To make a new frame to hold restored tabs at startup, or reuse the initial frame:

(setq bufferlo-bookmarks-load-at-emacs-startup-tabs-make-frame nil) ; reuse the initial frame (default)
(setq bufferlo-bookmarks-load-at-emacs-startup-tabs-make-frame t) ; make a new frame

Example auto-load predicate:

(setq 'bufferlo-bookmarks-load-predicate-functions #'bufferlo-bookmarks-load-all-p) ; loads all bookmarks

(defun my/bufferlo-bookmarks-load-p (bookmark-name)
  "Auto load bufferlo bookmarks that contain \"=al\"for autoload"
  (string-match-p (rx "=al") bookmark-name))
(add-hook 'bufferlo-bookmarks-load-predicate-functions #'my/bufferlo-bookmarks-load-p)

If you have configured bufferlo to load bookmarks at Emacs startup, you can inhibit bookmark loading without changing your configuration by either using the command line or a semaphore file in your user-emacs-directory:

$ emacs --bufferlo-noload
$ touch ~/.emacs.d/bufferlo-noload # remove it to reenable automatic loading

By default, bufferlo will save all buffers in the local frame/tab buffer list, using Emacs facilities to bookmark what's bookmarkable for restoration. You might want to exclude transient buffers *Completions* or *Help* or those which may not have bookmark support such as *shell* buffers. To do that, combine the following two variables, the first to exclude what you want to filter, and the second to ensure that the buffers you want to keep from the first filter are added back. For example:

(setq bufferlo-bookmark-buffers-exclude-filters
      (list
       (rx bos " " (1+ anything)) ; ignores "invisible" buffers; e.g., " *Minibuf...", " markdown-code-fontification:..."
       (rx bos "*" (1+ anything) "*") ; ignores "special" buffers; e.g;, "*Messages*", "*scratch*", "*occur*"
       ))

(setq bufferlo-bookmark-buffers-include-filters
      (list
       (rx bos "*shell*") ; if you have shell bookmark support
       (rx bos "*" (1+ anything) "-shell*") ; project.el shell buffers
       (rx bos "*eshell*")
       (rx bos "*" (1+ anything) "-eshell*") ; project.el eshell buffers
       ))

Bufferlo can discourage you from using multiple duplicate active bookmarks, but does not prevent them. Having duplicates is confusing and they present a race condition when saving as all copies will be saved, overwriting one another without regard to ordering, with the last one saved winning the race.

Note: The options to prevent duplicates are not enabled by default to maintain backward compatibility with previous versions of bufferlo, but they are likely to be enabled by default in the future.

(setq bufferlo-bookmarks-save-duplicates-policy 'prompt) ; default
(setq bufferlo-bookmarks-save-duplicates-policy 'allow) ; old default behavior
(setq bufferlo-bookmarks-save-duplicates-policy 'disallow) ; even better

If you use batch or automatic saving, this option lets you control which frames' bookmarks are saved. For example, some prefer not to have their current working set be saved unless and until they choose.

(setq bufferlo-bookmarks-save-frame-policy 'all) ; default
(setq bufferlo-bookmarks-save-frame-policy 'other) ; saves unselected frames' bookmarks
(setq bufferlo-bookmarks-save-frame-policy 'current) ; saves only the current frame bookmarks

Refine these options to suit your workflow as you gain experience with bufferlo. Refer to each option's documentation for additional settings.

;; make a new frame to hold loaded frame bookmarks
(setq bufferlo-bookmark-frame-load-make-frame t) ; default is nil for backward compatibility
(setq bufferlo-bookmark-frame-load-make-frame 'restore-geometry)

;; policy when loading onto an already bookmarked frame
(setq bufferlo-bookmark-frame-load-policy 'prompt) ; default
(setq bufferlo-bookmark-frame-load-policy 'replace-frame-retain-current-bookmark) ; old default behavior
(setq bufferlo-bookmark-frame-load-policy 'replace-frame-adopt-loaded-bookmark)
(setq bufferlo-bookmark-frame-load-policy 'merge) ; best selected via prompting to merge new tabs into the existing frame

;; allow duplicate active frame bookmarks in the Emacs session
(setq bufferlo-bookmark-frame-duplicate-policy 'prompt) ; default
(setq bufferlo-bookmark-frame-duplicate-policy 'allow) ; old default behavior
(setq bufferlo-bookmark-frame-duplicate-policy 'clear) ; silently clear the loaded frame bookmark
(setq bufferlo-bookmark-frame-duplicate-policy 'clear-warn) ; clear the loaded frame bookmark with a message
(setq bufferlo-bookmark-frame-duplicate-policy 'ignore) ; bypass loading the duplicate frame bookmark
(setq bufferlo-bookmark-frame-duplicate-policy 'raise) ; do not load, raise the existing frame

Note: 'raise is considered to act as 'clear by bookmark set loading.

Refine these options to suit your workflow as you gain experience with bufferlo. Refer to each option's documentation for additional settings.

;; make a new frame when loading a a batch of tab bookmarks
(setq bufferlo-bookmarks-load-tabs-make-frame nil) ; default, it reuses the current frame
(setq bufferlo-bookmarks-load-tabs-make-frame t) ; make a new tab when loading a batch of tab bookmarks

;; load a tab bookmark replacing the current tab or making a new tab
(setq bufferlo-bookmark-tab-replace-policy 'replace) ; default (backward compatible behavior)
(setq bufferlo-bookmark-tab-replace-policy 'new)

;; allow duplicate active tab bookmarks in the Emacs session
(setq bufferlo-bookmark-tab-duplicate-policy 'prompt) ; default
(setq bufferlo-bookmark-tab-duplicate-policy 'allow) ; old default behavior
(setq bufferlo-bookmark-tab-duplicate-policy 'clear) ; silently clear the loaded tab bookmark
(setq bufferlo-bookmark-tab-duplicate-policy 'clear-warn) ; clear the loaded tab bookmark with a message
(setq bufferlo-bookmark-tab-duplicate-policy 'ignore) ; bypass loading the duplicate tab bookmark
(setq bufferlo-bookmark-tab-duplicate-policy 'raise) ; do not load, raise the existing frame/tab

Note: 'raise is considered to act as 'clear by bookmark set loading.

;; allow inferior tab bookmark on a bookmarked frame (Note: frame bookmarks supersede tab bookmarks when saving)
(setq bufferlo-bookmark-tab-in-bookmarked-frame-policy 'prompt) ; default
(setq bufferlo-bookmark-tab-in-bookmarked-frame-policy 'allow) ; old default behavior
(setq bufferlo-bookmark-tab-in-bookmarked-frame-policy 'clear) ; silently clear the loaded tab bookmark
(setq bufferlo-bookmark-tab-in-bookmarked-frame-policy 'clear-warn) ; clear the loaded tab bookmark with a message

;; handle buffer bookmarks that could not be restored
(setq bufferlo-bookmark-tab-failed-buffer-policy nil) ; ignore; the default
(setq bufferlo-bookmark-tab-failed-buffer-policy 'placeholder) ; placeholder buffer and buffer name
(setq bufferlo-bookmark-tab-failed-buffer-policy 'placeholder-orig) ; placeholder buffer with original buffer name
(setq bufferlo-bookmark-tab-failed-buffer-policy "*scratch*") ; default to a specific buffer
(setq bufferlo-bookmark-tab-failed-buffer-policy #'my/failed-bookmark-handler) ; function to call that returns a buffer

Refine these options to suit your workflow as you gain experience with bufferlo. Refer to each option's documentation for additional settings.

;; frame geometry restoration policy
(setq bufferlo-set-restore-geometry-policy 'all) ; restore frame and tab-frame geometries; the default
(setq bufferlo-set-restore-geometry-policy 'frames) ; restore only frame geometries
(setq bufferlo-set-restore-geometry-policy 'tab-frames) ; restore only tab-frame geometries

The following option is useful for auto-loading bookmark sets at startup time or overlaying constituent tabs in the frame from which a bookmark set is loaded.

;; make a new frame when loading a a batch of tab bookmarks
(setq bufferlo-set-restore-tabs-reuse-init-frame 'reuse) ; reuse the existing first frame; the default
(setq bufferlo-set-restore-tabs-reuse-init-frame 'reuse-reset-geometry) ; like 'reuse but also alters the reused frame's geometry
(setq bufferlo-set-restore-tabs-reuse-init-frame nil) ; always make new frames

;; ignore already-active bufferlo bookmarks when loading a bookmark set
(setq bufferlo-set-restore-ignore-already-active nil) ; prompt for each duplicate bookmark; the default
(setq bufferlo-set-restore-ignore-already-active 'prompt) ; prompt to ignore already-active bookmarks in bulk
(setq bufferlo-set-restore-ignore-already-active 'ignore) ; always ignore already-active bookmarks

You can add your own functions to the following abnormal hooks to be called upon successful loading of tab, frame, and set bookmarks. See the docstrings for each function for its calling conventions.

Example: You could use a tab handler function to set the tab-bar group for each loaded tab to its source bookmark name. While tab-bar does have tab-bar-tab-post-open-functions, the bookmark context will not be available when those functions are called.

(add-hook 'bufferlo-bookmark-tab-handler-functions #'tab-bookmark-fun)
(add-hook 'bufferlo-bookmark-frame-handler-functions #'frame-bookmark-fun)
(add-hook 'bufferlo-bookmark-set-handler-functions #'set-bookmark-fun)

Bufferlo provides wrappers around Emacs frame functions to provide more precision. This is due to issues that affect make-frame and hence frameset-restore. One bug preventing pixel-level precision was reported and fixed for Emacs 31.

Frames stored in bufferlo frame bookmarks have their geometries stored individually and are recreated on demand. Bookmark sets frame collections are implemented via frameset-save and are restored by Emacs en masse.

Frame bookmarks saved via Emacs tty will not store a frame geometry (none available on tty). Conversely, frame bookmarks saved via GUI and restored on tty will ignore frame geometry.

Note: See below to adjust bufferlo-frame-sleep-for for your window manager.

Note: Not much testing has been done in hybrid tty/GUI environments using emacsclient, or with multi-display setups where frames may be expected to be restored on their originating displays.

;; function to determine a frame's pixelwise geometry (it is not
;; likely you will need to replace this--but is provided just in case)
(setq bufferlo-frame-geometry-function #'bufferlo-frame-geometry-default) ; the default uses text-width and text-height
(setq bufferlo-frame-geometry-function #'my/bufferlo-frame-geometry) ; or your own

;; function to set a frame's pixelwise geometry (it is not likely you
;; will need to replace this--but is provided just in case)
(setq bufferlo-set-frame-geometry-function #'bufferlo-set-frame-geometry-default)
(setq bufferlo-set-frame-geometry-function #'my/bufferlo-set-frame-geometry) ; or your own

;; seconds to sleep after each frame parameter change that requires
;; external window manager cooperation.
(setq bufferlo-frame-sleep-for 0) ; the default, which seems to work on macOS
(setq bufferlo-frame-sleep-for 0.3) ; seems to work for GTK/GNOME

;; methodology for bookmark-set frameset geometry restoration
(setq bufferlo-frameset-restore-geometry 'bufferlo) ; the pixel-level precision default
(setq bufferlo-frameset-restore-geometry 'native) ; uses `frameset-restore' geometry handling (buggy pre Emacs 31)
(setq bufferlo-frameset-restore-geometry nil) ; inhibit frame geometry restoration

;; inhibit additional frame parameter symbols from being stored by `frameset-save'
(setq bufferlo-frameset-save-filter nil)
(setq bufferlo-frameset-save-filter '(my:frame-id ; practical example
				      zoom--frame-snapshot))

;; inhibit additional frame parameter symbols from being restored by `frameset-restore'
(setq bufferlo-frameset-restore-filter nil)

;; you can override bufferlos `frameset-restore' wrapper should you need to
(setq bufferlo-frameset-restore-function #'bufferlo-frameset-restore-default) ; the default
;; a practical example that inhibits user-configured
;; `after-make-frame-functions' frame maximization by let-binding
;; my:frame-maximize to nil allowing `frameset-restore' and bufferlo
;; to control restored frame geometry.
(defun my/bufferlo-frameset-restore-function (frameset)
  (let ((my:frame-maximize nil))
    (bufferlo-frameset-restore-default frameset)))
(setq bufferlo-frameset-restore-function #'my/bufferlo-frameset-restore-function)

(setq bufferlo-frameset-restore-parameters-function #'bufferlo-frameset-restore-parameters-default) ; default
;; a practical example where Emacs Linux/GTK behaves differently vs. macOS
(defun my/bufferlo-frameset-restore-parameters ()
  "Function to create parameters for `frameset-restore', which see."
  (cond (my:on-linux-gnome
	 (list :reuse-frames nil
	       :force-display nil ; bufferlo defaults to t which works on macOS
	       :force-onscreen (display-graphic-p)
	       :cleanup-frames nil))
	(t
	 (bufferlo-frameset-restore-parameters-default))))
(setq bufferlo-frameset-restore-parameters-function #'my/bufferlo-frameset-restore-parameters)

Emacs bookmarks do not store your file or buffer contents, only references to your files and buffers. Many Emacs modes support Emacs bookmarks and can be saved and recalled including eshell and magit-status buffers. The state of non-bookmarkable buffers is not saved. However, during bookmark saving, they are included in the bookmark record. Emacs 31 has support for shell-mode local and remote buffer bookmarks.

Restoring bookmarks correctly handles renamed buffers with unchanged file association (e.g., when Emacs had to "uniquify" buffer names).

If files are deleted between Emacs sessions and a bookmarked buffer cannot be restored, after loading a bookmark with a missing file, a message similar to this can be found in your *Messages* buffer:

Bufferlo bookmark: Could not restore file.txt (error (bookmark-error-no-filename stringp /etc/file.txt))

Please note: Emacs bookmark-jump-other-frame and bookmark-jump-other-window commands are not compatible with bufferlo bookmarks. A future version of bufferlo might wrap these functions for convenience to either provide a warning or provide alternative jump functionality.

It can be convenient to share bookmark files among your computers or among colleagues. Bookmarks can be made more "portable" with the following assumptions:

• You share an Emacs configuration including packages, mode settings, etc.
• You share a directory hierarchy for files in common such as programming or writing projects on which you collaborate.

Bufferlo uses completing-read-multiple for the prompts where you can specify more than one input selection; e.g., when opening multiple bookmarks at once using bufferlo-bookmarks-load-interactive. Emacs 31 will be getting a proper CRM prompt that displays the CRM separator character as a reminder hint. Note: The default separator is a comma.

Per vertico#completing-read-multiple from the author of the Emacs CRM patch, we recommend adding the following snippet to your Emacs configuration.

;; Prompt indicator for `completing-read-multiple'.
(when (< emacs-major-version 31)
  (advice-add #'completing-read-multiple :filter-args
	      (lambda (args)
		(cons (format "[CRM%s] %s"
			      (string-replace "[ \t]*" "" crm-separator)
			      (car args))
		      (cdr args))))))