Emacs Dashboard installation, widgets, and startup configuration

What Emacs Dashboard changes at Emacs startup

Emacs Dashboard addresses a familiar startup problem: opening Emacs gives the user an empty buffer unless they immediately visit a file or restore a useful workspace. The project replaces that blank starting point with a dashboard assembled from information already available in Emacs. Its documented widgets include recent files, bookmarks, recent projects, Org mode agenda entries, and registers. It also supplies a banner, section navigation, footer content, and configurable item counts.

The intended audience is Emacs users who want their file history, bookmarks, and project context visible in one place. This is a presentation and startup-buffer package rather than a replacement for Emacs file management, Org mode, bookmarks, or project management. Those sources still supply the underlying data. Dashboard determines which widgets appear, in what order they are inserted, and how many entries each widget displays.

Most functionality does not require an additional service or separate executable. Optional packages add icon rendering or project discovery. The project widget, in particular, is disabled by default because it depends on either `projectile` or `project.el`. That choice keeps installation lightweight, but it also means the most context-heavy feature needs an explicit backend choice.

How dashboard.el constructs the startup buffer

The repository is implemented primarily in Emacs Lisp. Its main implementation is in `dashboard.el`, with widget-related definitions in `dashboard-widgets.el`. According to the README, initialization and buffer construction are driven by functions including `dashboard-initialize`, `dashboard-insert-startupify-lists`, and the insertion functions listed in `dashboard-startupify-list`.

Configuration separates selected data from the sequence used to render it. `dashboard-items` identifies widgets such as recents, bookmarks, projects, agenda, and registers. A numeric value controls how many entries that widget shows. The `dashboard-startupify-list` variable then defines the order of insertion functions, including the banner, navigator, initialization information, items, and footer. This separation gives users direct control over both content and layout without requiring a replacement extension.

Dashboard is designed to be re-opened as a buffer rather than remain permanently installed in one frame. `dashboard-open` opens it interactively, while `dashboard-refresh-buffer` is documented as an alias for `dashboard-open` and can revisit or refresh the dashboard. For an Emacs daemon, `initial-buffer-choice` can direct frames created with `emacsclient -c` to the same dashboard opening function.

Installing Dashboard and opening it for the first time

The README directs users to install the package through Emacs's built-in `package-install` command. Run this inside Emacs, then enter `dashboard` as the package name. The result should be an available `dashboard` package. After installation, load it and register the startup hook if the dashboard should open automatically on later Emacs sessions.

Enabling project and daemon-backed dashboard behavior

The projects widget illustrates Dashboard's dependency model. It is not enabled by default because its data source is external to the project. A user who wants recent projects must first choose `projectile` or `project-el` through `dashboard-projects-backend`, then add a projects entry to `dashboard-items`. Without both steps, configuring the item count alone does not establish a project source.

The daemon integration addresses a separate startup path. A normal Emacs startup hook does not necessarily cover frames opened later by the server. Setting `initial-buffer-choice` to the symbol `dashboard-open` makes those client-created frames use Dashboard as their initial buffer function. This is useful for `emacsclient -c`, but it changes server behavior rather than merely refreshing an already open Dashboard.

Icon packages can require a buffer refresh after their fonts or icon setup becomes available. The README adds `server-after-make-frame-hook` and calls `dashboard-open` for that case. A user should therefore distinguish an ordinary on-demand refresh from the daemon hooks used to open or redraw the dashboard in newly created frames.

Custom widgets and layout through Dashboard variables

Dashboard exposes both item selection and insertion order. The documented `dashboard-items` setting can include recents, bookmarks, projects, agenda, and registers, each with an entry limit. For example, a value of five requests up to five visible entries for that widget. The number describes presentation, not a new storage or synchronization mechanism.

Layout is controlled separately through `dashboard-startupify-list`. Users can place the banner, newlines, navigator, initialization information, item insertion, and footer in a chosen sequence. Other documented variables address presentation details such as centering content, vertical centering, banner title, banner image type, and shortcut indicators. Supported banner values include official and alternative logos, ANSI color variants, Braille, numbered built-in banners, custom file paths, and paired image and text fallback paths.

This configuration surface is useful for an existing Emacs setup, but it also creates a maintenance responsibility. Startup hooks, package configuration, project backends, icon refresh hooks, and custom widget order can all live in the user's Emacs Lisp configuration. Upgrading the package does not automatically decide which Dashboard widgets remain appropriate or remove configuration written for older behavior.

Licensing, maintenance, and upgrade boundaries

The project is distributed under the `GPL-3.0` license. That identifier identifies the repository's declared licensing terms, but this review does not provide legal advice or determine how a particular distribution or deployment satisfies license obligations.

The repository is not archived. Its last push was on 2026-08-09, while the documented release history lists version `1.8.0` on 2023-07-26, followed by `1.7.0` on 2020-02-21 and `1.6.0` on 2019-06-07. The repository has received a more recent push than its newest documented release, but the README and repository metadata do not explain what changed after the last release. Consequently, users should distinguish repository changes from package-release availability rather than assuming that every commit is represented in a published version.

The repository also includes `CHANGELOG.md`, documentation, tests, and a Makefile. The Makefile exposes `package`, `install`, `compile`, `test`, `checkdoc`, `lint`, and `clean` targets through `eask`. These are development and packaging operations, not additional runtime configuration. The README does not document a rollback procedure or a formal upgrade-compatibility policy, so users should inspect `CHANGELOG.md` and their local Emacs Lisp configuration before changing package versions.

Editorial conclusion

Emacs Dashboard is appropriate for users who want an information-oriented Emacs startup buffer and already maintain recent files, bookmarks, or Org projects. It is a poorer fit for users who prefer a minimal startup screen or do not have a compatible project backend. Before adopting it, verify `dashboard-items`, the selected `dashboard-projects-backend`, and the startup-hook integration in your own Emacs configuration.

Frequently asked questions

Official sources

1. emacs-dashboard/dashboard on GitHub
2. License: GPL-3.0
3. Project website
4. README
5. Releases