bufler.info

This is README.info, produced by makeinfo version 6.7 from README.texi.

INFO-DIR-SECTION Emacs
START-INFO-DIR-ENTRY
* Bufler: (bufler).     Group buffers into workspaces with programmable rules, and easily switch to and manipulate them.
END-INFO-DIR-ENTRY


File: README.info,  Node: Top,  Next: Screenshots,  Up: (dir)

Bufler.el
*********

Bufler is like a butler for your buffers, presenting them to you in an
organized way based on your instructions.  The instructions are written
as grouping rules in a simple language, allowing you to customize the
way buffers are grouped.  The default rules are designed to be generally
useful, so you don’t have to write your own.

   It also provides a workspace mode which allows frames to focus on
buffers in certain groups.  Since the groups are created automatically,
the workspaces are created dynamically, rather than requiring you to put
buffers in workspaces manually.

* Menu:

* Screenshots::
* Installation::
* Usage::
* Compared to Ibuffer::
* Changelog::
* Credits::
* Development::
* License::

— The Detailed Node Listing —

Installation

* Quelpa::

Usage

* Workflow::
* Commands::
* Bindings::
* Tips::
* Defining groups::
* Helm support::
* Ivy support::
* Prism support::

Defining groups

* Default groups example::
* Group types::

Changelog

* 0.4-pre: 04-pre.
* 0.3: 03.
* 0.2: 02.
* 0.1: 01.



File: README.info,  Node: Screenshots,  Next: Installation,  Prev: Top,  Up: Top

1 Screenshots
*************

This screenshot shows ‘bufler-list’ in the top window, and
‘bufler-switch-buffer’ reading a buffer with completion in the bottom
window.  Note how the same, recursively grouped buffers are shown in
both ways.

   This screenshot compares Bufler and Ibuffer showing the same buffers
with the default settings.  Note how Bufler provides collapsible
sections to group and hide uninteresting buffers.  It also allows
commands to be applied to selected sections: for example, pressing ‘k’
in this Bufler list would kill the buffers in the groups
‘compilation-mode’ and ‘completion-list-mode’ (and, of course, since it
calls ‘kill-buffer’, any unsaved, file-backed buffers would ask to be
saved first).

   This screenshot shows Bufler Tabs Mode, which works with the new
‘tab-bar-mode’ and ‘tab-line-mode’ from Emacs 27.  The ‘tab-bar’ selects
the workspace, and the ‘tab-line’ selects a buffer in the current
workspace.


File: README.info,  Node: Installation,  Next: Usage,  Prev: Screenshots,  Up: Top

2 Installation
**************

If you’ve installed from MELPA (https://melpa.org/), you’re done!

* Menu:

* Quelpa::


File: README.info,  Node: Quelpa,  Up: Installation

2.1 Quelpa
==========

If you prefer, you may install with quelpa-use-package
(https://github.com/quelpa/quelpa-use-package), like this:

     (use-package bufler
       :quelpa (bufler :fetcher github :repo "alphapapa/bufler.el"
                       :files (:defaults (:exclude "helm-bufler.el"))))

   To install the additional ‘helm-bufler’ package, use:

     (use-package helm-bufler
       :quelpa (helm-bufler :fetcher github :repo "alphapapa/bufler.el"
                            :files ("helm-bufler.el")))


File: README.info,  Node: Usage,  Next: Compared to Ibuffer,  Prev: Installation,  Up: Top

3 Usage
*******

Bufler provides four primary, user-facing features.  They complement
each other, but each one may be used independently.

  1. The command ‘bufler’ shows a list of buffers grouped according to
     the defined grouping rules.  It allows manipulation of buffers and
     groups of buffers.
  2. The command ‘bufler-switch-buffer’ prompts for a buffer with
     completion and switches to the selected one.  Buffers are presented
     by their "path" in the groups.
  3. The global minor mode ‘bufler-mode’ allows each frame to have a
     "workspace," which is a buffer group selected by the user.  When
     the mode is active, the command ‘bufler-switch-buffer’ presents
     only buffers from the current workspace (unless called with a
     prefix, in which case it shows all buffers), and the current
     workspace is displayed in the mode line and the frame’s title.
     Buffers can also be manually assigned to named workspaces.
  4. The global minor mode ‘bufler-tabs-mode’ uses the new Emacs 27
     ‘tab-bar’ and ‘tab-line’ features to display workspaces and
     buffers.  The ‘tab-bar’ shows top-level workspaces (and whatever
     the selected one is, even if not top-level), and the ‘tab-line’
     shows buffers from the current workspace.

   • • • • • • • • 
* Menu:

* Workflow::
* Commands::
* Bindings::
* Tips::
* Defining groups::
* Helm support::
* Ivy support::
* Prism support::


File: README.info,  Node: Workflow,  Next: Commands,  Up: Usage

3.1 Workflow
============

A workflow using Bufler could be something like this:

  1. Start Emacs.
  2. Activate ‘bufler-mode’.
  3. Open some buffers, find some files, etc.
  4. When you need to switch buffers, use ‘M-x bufler-switch-buffer’.
     The buffers are presented by group with their "outline paths,"
     which makes it easier to find the buffer you’re looking for, since
     they’re organized by project, directory, mode, etc.
  5. If you want to focus on a certain group’s buffers:
       1. Use ‘C-u C-u M-x bufler-switch-buffer RET’ and select a
          buffer; or
       2. Use ‘M-x bufler-workspace-frame-set RET’ and select a
          workspace; or
       3. Use ‘M-x bufler RET’ and press ‘f’ to focus the current frame
          on a workspace, or ‘F’ to open a new frame focused on a
          workspace.
  6. The next time you call ‘bufler-switch-buffer’ in that frame, it
     will only offer buffers from that frame’s buffer group, making it
     easier to find buffers related to the current project.  (Of course,
     existing commands like ‘switch-to-buffer’ are not affected; Bufler
     doesn’t interfere with other modes or commands.)
  7. When you need to switch to a buffer in a different group without
     changing the frame’s workspace, use ‘C-u M-x bufler-switch-buffer’
     to select from all buffers in all groups.
  8. When you need to kill or save a bunch of buffers at once, use
     ‘bufler-list’, put the cursor on a group you want to kill or save,
     and press ‘k’ or ‘s’.  If you want to see which buffers have
     unsaved (indicated with ‘*’) or uncommitted (indicated with
     ‘edited’) changes, you can browse through the list of buffers
     (enable ‘bufler-vc-state’ to show VC state for each buffer; this is
     disabled by default because getting up-to-date information on a
     buffer’s VC state can be slow).

   Then, you can write your own buffer-grouping rules to make them as
simple or as complex as you like.  They’re just Lisp functions, so you
can do anything with them, but the DSL provided by the macro makes
simple ones easy to write.


File: README.info,  Node: Commands,  Next: Bindings,  Prev: Workflow,  Up: Usage

3.2 Commands
============

‘bufler’
     Show the Bufler buffer list.
‘bufler-mode’
     Enable the Bufler workspace mode, which allows each frame to have a
     chosen workspace from Bufler’s groups.
‘bufler-tabs-mode’
     Enable the Bufler workspace tabs mode, which uses ‘tab-bar-mode’
     and ‘tab-line-mode’ from Emacs 27+ to display Bufler workspaces and
     buffers.
‘bufler-switch-buffer’
     Switch to a buffer selected from the frame’s workspace.  Without
     any input, switch to the previous buffer.  With prefix, select from
     all buffers.  With two prefixes, also set the frame’s workspace.
‘bufler-workspace-focus-buffer’
     Set current frame’s workspace to the current buffer’s workspace.
‘bufler-workspace-frame-set’
     Set the frame’s workspace.  Setting the workspace may be done
     automatically by ‘bufler-switch-buffer’, but this command may be
     used to set the workspace to a group containing other groups, after
     which ‘bufler-switch-buffer’ will present buffers from the selected
     group and its subgroups.
‘bufler-workspace-buffer-set’
     Set the current buffer’s workspace name.  With prefix, unset it.
     Note that, in order for a buffer to appear in a named workspace,
     the buffer must be matched by an ‘auto-workspace’ group before any
     other group.


File: README.info,  Node: Bindings,  Next: Tips,  Prev: Commands,  Up: Usage

3.3 Bindings
============

In the Bufler buffer list, these keys are available (use ‘C-h m’ to get
the most up-to-date listing).  They operate on all buffers in the
section at point.

   • ‘?’ Show key bindings Hydra.
   • ‘1’ – ‘4’ Cycle section levels at point.
   • ‘M-1’ – ‘M-4’ Cycle top-level sections.
   • ‘RET’ Switch to buffer.
   • ‘SPC’ Peek at buffer, keeping focus in buffer list.
   • ‘g’ Refresh Bufler list (with prefix, force updating buffers’ VC
     state and grouping).
   • ‘f’ Set the current frame’s workspace to the group at point (with
     prefix, unset).
   • ‘F’ Make a new frame whose workspace is the group at point.
   • ‘N’ Add buffers to named workspace (with prefix, remove from it).
   • ‘k’ Kill buffers.
   • ‘s’ Save buffers.


File: README.info,  Node: Tips,  Next: Defining groups,  Prev: Bindings,  Up: Usage

3.4 Tips
========

   • ‘bufler-switch-buffer’ works best when ‘completion-styles’ includes
     the ‘substring’ style.  It also works well with ‘helm-mode’ and
     ‘ivy-mode’.
   • Customize settings in the ‘bufler’ group.


File: README.info,  Node: Defining groups,  Next: Helm support,  Prev: Tips,  Up: Usage

3.5 Defining groups
===================

   • • 
   _See the ‘bufler’ info page to view this information in Emacs._

   The Bufler groups definition is a list stored in variable
‘bufler-groups’.  Each element of the list is a function which takes a
buffer as its only argument and returns a string naming the group the
buffer should be in at that level (or nil if the buffer should not be
grouped by the function), or a list of such functions; each list may
contain more such lists.  Each buffer is matched against these functions
in-order until the list of functions is exhausted.  A list of functions
defines a subgroup which short-circuits other groups at the same level,
preventing further grouping outside of the subgroup’s functions.
Ultimately, it’s functions all the way down.

   If this explanation doesn’t seem clear, please see the examples.
Once you get the hang of it, it’s powerful and flexible.

   For convenience, the macro ‘bufler-defgroups’ provides a concise
vocabulary for defining groups.  *Note* that the macro does not _set_
the variable ‘bufler-groups’, it only expands a groups form, so you
should use, e.g.  ‘(setf bufler-groups (bufler-defgroups ...))’ to
actually set the groups.

* Menu:

* Default groups example::
* Group types::


File: README.info,  Node: Default groups example,  Next: Group types,  Up: Defining groups

3.5.1 Default groups example
----------------------------

The default groups are defined like this:

     (bufler-defgroups
       (group
        ;; Subgroup collecting all named workspaces.
        (auto-workspace))
       (group
        ;; Subgroup collecting all `help-mode' and `info-mode' buffers.
        (group-or "*Help/Info*"
                  (mode-match "*Help*" (rx bos "help-"))
                  (mode-match "*Info*" (rx bos "info-"))))
       (group
        ;; Subgroup collecting all special buffers (i.e. ones that are not
        ;; file-backed), except `magit-status-mode' buffers (which are allowed to fall
        ;; through to other groups, so they end up grouped with their project buffers).
        (group-and "*Special*"
                   (lambda (buffer)
                     (unless (or (funcall (mode-match "Magit" (rx bos "magit-status"))
                                          buffer)
                                 (funcall (mode-match "Dired" (rx bos "dired"))
                                          buffer)
                                 (funcall (auto-file) buffer))
                       "*Special*")))
        (group
         ;; Subgroup collecting these "special special" buffers
         ;; separately for convenience.
         (name-match "**Special**"
                     (rx bos "*" (or "Messages" "Warnings" "scratch" "Backtrace") "*")))
        (group
         ;; Subgroup collecting all other Magit buffers, grouped by directory.
         (mode-match "*Magit* (non-status)" (rx bos (or "magit" "forge") "-"))
         (auto-directory))
        ;; Subgroup for Helm buffers.
        (mode-match "*Helm*" (rx bos "helm-"))
        ;; Remaining special buffers are grouped automatically by mode.
        (auto-mode))
       ;; All buffers under "~/.emacs.d" (or wherever it is).
       (dir user-emacs-directory)
       (group
        ;; Subgroup collecting buffers in `org-directory' (or "~/org" if
        ;; `org-directory' is not yet defined).
        (dir (if (bound-and-true-p org-directory)
                 org-directory
               "~/org"))
        (group
         ;; Subgroup collecting indirect Org buffers, grouping them by file.
         ;; This is very useful when used with `org-tree-to-indirect-buffer'.
         (auto-indirect)
         (auto-file))
        ;; Group remaining buffers by whether they're file backed, then by mode.
        (group-not "*special*" (auto-file))
        (auto-mode))
       (group
        ;; Subgroup collecting buffers in a projectile project.
        (auto-projectile))
       (group
        ;; Subgroup collecting buffers in a version-control project,
        ;; grouping them by directory.
        (auto-project))
       ;; Group remaining buffers by directory, then major mode.
       (auto-directory)
       (auto-mode))


File: README.info,  Node: Group types,  Prev: Default groups example,  Up: Defining groups

3.5.2 Group types
-----------------

The following group types are available in ‘bufler-defgroups’.  Note
that each one is expanded into a lambda, so they may also be called by
‘funcall’ (see example above).

Meta types
     These types compose multiple of the other types into a single
     group.
        • ‘group (TYPE...)’ Define a subgroup matching given types,
          which short-circuits other groups at the same level.
        • ‘group-not (NAME TYPE)’ Groups buffers which do _not_ match
          the given type.
        • ‘group-and (NAME TYPE...)’ Groups buffers which match all of
          the given types.
        • ‘group-or (NAME TYPE...)’ Groups buffers which match any of
          the given types.
Auto types
     These types automatically create groups for the buffer’s attribute
     of this type.
        • ‘auto-directory’ Buffer’s directory.
        • ‘auto-file’ Buffer’s file name.
        • ‘auto-indirect’ Whether the buffer is indirect (e.g.  a cloned
          indirect buffer).
        • ‘auto-mode’ Buffer’s major mode.
        • ‘auto-project’ Buffer’s version-control project directory
          according to ‘project.el’.
             • ‘auto-parent-project’ Like ‘auto-project’, but if the
               buffer’s parent directory is in a different project, use
               that one instead.  Useful for git worktrees, where
               ‘auto-project’ would show each worktree as a separate
               project.
        • ‘auto-projectile’ Buffer’s project as defined in the
          ‘projectile’ package (if installed).
        • ‘auto-special’ Whether the buffer is special (i.e.  whether
          its name starts with ‘*’).
        • ‘auto-tramp’ Whether the buffer is opened via Tramp.
        • ‘auto-workspace’ The buffer’s named workspace, if any.
Regexp types
     These types match a value against a buffer’s attribute and group
     buffers which match.
        • ‘filename-match (NAME REGEXP)’ Match a regular expression
          against the buffer’s filename, if it has one.
        • ‘name-match (NAME REGEXP)’ Match a regular expression against
          the buffer’s name.
        • ‘mode-match (NAME REGEXP)’ Match a regular expression against
          the buffer’s major-mode.
Other types
        • ‘dir (DIRS DEPTH)’ Groups buffers which match one of the given
          DIRS.  DIRS may be one or a list of directory paths.  DEPTH
          may be nil or a depth above which to produce subdirectory
          groups (a feature probably broken at the moment).  See example
          above.
        • ‘hidden’ Groups buffers which are hidden (i.e.  whose names
          start with a space and do not visit a file).


File: README.info,  Node: Helm support,  Next: Ivy support,  Prev: Defining groups,  Up: Usage

3.6 Helm support
================

Bufler does not require nor depend on Helm, but because it uses
‘completing-read’, it requires no special configuration to work with
‘helm-mode’ for selecting buffers.

   To show Bufler’s grouped buffers in a Helm-specific command, a
separate ‘helm-bufler’ package is available, which includes
‘helm-bufler-source’, a Helm source that shows buffers in the current
workspace (or when the Helm command is called with ‘C-u’, all buffers).
It looks like this when showing all buffers:

   After installing the package (see above), use it like this:

     (helm :sources '(helm-bufler-source))


File: README.info,  Node: Ivy support,  Next: Prism support,  Prev: Helm support,  Up: Usage

3.7 Ivy support
===============

Bufler does not require nor depend on Ivy, but because it uses
‘completing-read’, Bufler requires no special configuration to work with
‘ivy-mode’ for selecting buffers.  For example, this shows
‘bufler-switch-buffer’ with ‘ivy-mode’ activated (in the
‘spacemacs-dark’ theme):


File: README.info,  Node: Prism support,  Prev: Ivy support,  Up: Usage

3.8 Prism support
=================

Bufler does not require nor depend on Prism
(https://github.com/alphapapa/prism.el), but you can use Prism’s level
faces with Bufler by using ‘M-x customize-option RET bufler-face-prefix
RET’ and choosing the ‘Prism faces’ option.  For example (showing an
earlier version of the package, when it was called Sbuffer):


File: README.info,  Node: Compared to Ibuffer,  Next: Changelog,  Prev: Usage,  Up: Top

4 Compared to Ibuffer
*********************

Bufler is primarily about grouping buffers automatically and
dynamically, using smart, customizeable rules.  While Ibuffer provides
some powerful grouping features, they are restricted to single-level
grouping, and they require extensive, manual configuration.  Bufler
offers recursive, multi-level grouping, and a set of default groups is
provided which are designed to be generally useful.  Bufler presents
groups in ‘bufler-list’ using the ‘magit-section’ library, which allows
groups and buffers to be toggled, marked, and operated on with commands.

   Ibuffer groups must be manually and individually specified.  So, for
example, to group project A’s buffers into one group, and project B’s
into another, Ibuffer requires the user to make a group for each
project.  Bufler provides a set of automatic grouping rules that create
groups automatically.  For example, with the rule ‘(auto-project)’,
Bufler would create one group for project A’s buffers and another for
project B’s.  When those projects’ buffers are closed, the groups are
automatically removed.

   Bufler also provides optional workspace features in the form of
‘bufler-mode’, which helps focus a frame on a group of buffers.  When
it’s active, the command ‘bufler-switch-buffer’ presents buffers from
that frame’s selected workspace; when called with a prefix argument, it
presents all buffers, and then switches the frame’s workspace to the
selected buffer’s group.

   Of course, Ibuffer is a mature tool with many features, so Bufler
doesn’t replace it completely.  Bufler is a very young project.


File: README.info,  Node: Changelog,  Next: Credits,  Prev: Compared to Ibuffer,  Up: Top

5 Changelog
***********

* Menu:

* 0.4-pre: 04-pre.
* 0.3: 03.
* 0.2: 02.
* 0.1: 01.


File: README.info,  Node: 04-pre,  Next: 03,  Up: Changelog

5.1 0.4-pre
===========

This release includes additional support for Emacs’s ‘tab-bar-mode’.
Basically, commands and features that formerly acted on the current
frame now act on the current tab when ‘tab-bar-mode’ is active,
otherwise on the current frame.

   Notably, these changes are also designed to facilitate integration
with Burly (https://github.com/alphapapa/burly.el)’s ‘burly-tabs-mode’
(e.g.  when a Burly bookmark is opened in a ‘tab-bar’ tab, the tab’s
Bufler workspace can be set to the workspace containing the buffer, so
that ‘bufler-switch-buffer’ automatically offers buffers relevant to the
tab).

   Note as well that the existing
‘bufler-workspace-workspaces-as-tabs-mode’ _overrides_ some aspects of
Emacs’s ‘tab-bar-mode’ and ‘tab-line-mode’; this functionality is still
somewhat experimental and may not suit every user’s taste.  But while
that mode may remain disabled, Bufler’s other features are still useful
with standard ‘tab-bar-mode’.  (_Yes, all these names and modes and
features do get confusing.  The term "workspaces" is vague, encompassing
a variety of ideas envisioned by a range of users.  Bufler’s
implementation is just one iteration of the concept._)

   *Additions*

   • Command ‘bufler-workspace-set’ sets the workspace of the current
     ‘tab-bar’ tab or frame.
   • Option ‘bufler-workspace-switch-buffer-and-tab’ (enabled by
     default) automatically switches to a buffer’s workspace’s tab, if
     it has one, when using ‘bufler-switch-buffer’.  (This tries to
     solve the age-old problem of buffers not "staying in their
     workspace.")
   • Commands ‘bufler-workspace-open’ and ‘bufler-workspace-save’.
     These open and save workspaces using Burly
     (https://github.com/alphapapa/burly.el) as a backend (which is now
     a dependency).  (This is basically like calling
     ‘burly-open-bookmark’ and ‘burly-bookmark-windows’, but integrating
     some ‘bufler-workspace’ features automatically.)
   • Option ‘bufler-workspace-prefix-abbreviation’, which abbreviates
     workspace names in tab/frame names.
   • Option ‘bufler-switch-buffer-include-recent-buffers’ includes
     recently shown buffers in the ‘bufler-switch-buffer’ command’s list
     of buffers.

   *Changes*

   • Command ‘bufler-workspace-focus-buffer’ sets the workspace of the
     current ‘tab-bar’ tab or frame to the current buffer’s workspace.
   • Command ‘bufler-workspace-switch-buffer’ offers buffers from the
     workspace of the current ‘tab-bar’ tab or frame.
   • Mode ‘bufler-workspace-mode’’s mode-line lighter shows the path of
     the current ‘tab-bar’ tab or frame.

   *Fixes*

   • The ‘dir’ buffer group uses the base buffer’s directory for
     indirect buffers.
   • When testing whether two directories are related, both the paths
     as-given and the canonicalized paths are compared (so that if a
     subdirectory is a symlink to a directory outside the parent
     directory, it will still be considered related).


File: README.info,  Node: 03,  Next: 02,  Prev: 04-pre,  Up: Changelog

5.2 0.3
=======

*Added*
   • Group type ‘auto-parent-project’.
   • Option ‘bufler-vc-remote’, which controls the displaying of the
     version control state of remote files (default: off).  (Fixes #41
     (https://github.com/alphapapa/bufler.el/issues/41).  Thanks to Tory
     S.  Anderson (https://github.com/WorldsEndless) for reporting.)
   • Option ‘bufler-workspace-format-path-fn’, which formats group paths
     for display in mode lines and frame titles (e.g.  it may be
     customized to show just the last element).
   • Show an asterisk next to buffers with unsaved changes.  (Thanks to
     Tatu Lahtela (https://github.com/ration).)
   • Name and path columns optionally limit width to that defined in
     their customization options.  (Thanks to Tory S.  Anderson
     (https://github.com/WorldsEndless).)
   • Column ‘Mode’ shows buffer’s major mode, sans ‘-mode’ suffix.
   • More filtering options: ‘bufler-filter-buffer-fns’,
     ‘bufler-workspace-switch-buffer-filter-fns’,
     ‘bufler-filter-buffer-modes’, and
     ‘bufler-filter-buffer-name-regexps’.  By default, more buffers will
     be hidden in ‘bufler-list’ and ‘bufler-switch-buffer’, and filters
     may be disabled by calling those commands with universal prefix
     arguments.
   • Option ‘bufler-list-display-buffer-action’, which controls how the
     ‘bufler-list’ buffer is displayed.
   • Option ‘bufler-list-switch-buffer-action’, which controls how
     buffers are displayed when switched to from the buffer list.
     (Fixes #76 (https://github.com/alphapapa/bufler.el/issues/76).
     Thanks to Julian M.  Burgos (https://github.com/jmburgos), Tory S.
     Anderson (https://github.com/WorldsEndless), and jcalve
     (https://github.com/jcalve) for reporting.)
   • Option ‘bufler-indent-per-level’, which sets the indentation
     applied per level of depth.
   • Command ‘bufler-sidebar’ displays the Bufler list in a side window.
   • Project metadata cache (because the ‘project-current’ function can
     be slow when called for many paths in rapid succession, as when
     many buffers are open).

   *Fixed*
   • Option ‘bufler-filter-buffer-modes’ had the wrong customization
     type.
   • Depend on at least version 2.1 of the ‘map’ package (required for
     ‘pcase’ macro expansion).
   • Columns’ ‘max-width’ options.  (Fixes #79
     (https://github.com/alphapapa/bufler.el/issues/79).  Thanks to Tory
     S.  Anderson (https://github.com/WorldsEndless) for reporting.)

   *Changed*
   • Don’t show ‘*xref*’ buffers by default.
   • Command ‘bufler-switch-buffer’ allows entering a non-existent
     buffer name to create a buffer and switch to it (like
     ‘switch-to-buffer’).


File: README.info,  Node: 02,  Next: 01,  Prev: 03,  Up: Changelog

5.3 0.2
=======

Project expanded and renamed from Sbuffer to Bufler.


File: README.info,  Node: 01,  Prev: 02,  Up: Changelog

5.4 0.1
=======

First tagged release.


File: README.info,  Node: Credits,  Next: Development,  Prev: Changelog,  Up: Top

6 Credits
*********

   • Thanks to Jonas Bernoulli (https://github.com/tarsius) for
     magit-section
     (https://github.com/magit/magit/blob/master/lisp/magit-section.el).
   • Thanks to Magnar Sveen (https://github.com/magnars/dash.el) and
     Matus Goljer (https://github.com/Fuco1) for dash.el
     (https://github.com/magnars/dash.el).
   • Thanks to Johan Andersson (https://github.com/rejeep) for f.el
     (https://github.com/rejeep/f.el).
   • Thanks to Jerry Peng (https://github.com/jerrypnz) for Pretty Hydra
     (https://github.com/jerrypnz/major-mode-hydra.el#pretty-hydra).


File: README.info,  Node: Development,  Next: License,  Prev: Credits,  Up: Top

7 Development
*************

Bufler bufler bufler bufler bufler bufler bufler bufler.


File: README.info,  Node: License,  Prev: Development,  Up: Top

8 License
*********

GPLv3



Tag Table:
Node: Top258
Node: Screenshots1370
Node: Installation2440
Node: Quelpa2649
Node: Usage3228
Node: Workflow4799
Node: Commands7059
Node: Bindings8523
Node: Tips9455
Node: Defining groups9796
Node: Default groups example11183
Node: Group types14110
Node: Helm support17056
Node: Ivy support17802
Node: Prism support18229
Node: Compared to Ibuffer18669
Node: Changelog20419
Node: 04-pre20599
Node: 0323807
Node: 0226719
Node: 0126860
Node: Credits26959
Node: Development27648
Node: License27818

End Tag Table


Local Variables:
coding: utf-8
End: