This is a repository of official modules for Doom Emacs. They are more closely looked after by Doom’s author. If a module you want isn’t here, check our sibling repository for community-maintained modules: doomemacs/contrib-modules, which also serves as a staging ground for new modules.
📌 Technical documentation on the anatomy of Doom modules can be found in the official developer’s manual.
- @hlissner
Become a maintainer?
This module does not have a changelog yet.
This module repository is included with Doom Emacs (for now). No additional
setup is needed to add them. However, the modules themselves can be toggled in
your doom! block.
Remember to check their documentation (listed and linked below) for additional setup instructions.
Application modules are complex and opinionated modules that transform Emacs toward a specific purpose. They may have additional dependencies and should be loaded last (but before doom-module::config modules).
Watch your missed deadlines in real time
This module adds a calendar view for Emacs, with org and google calendar sync support.
A media player for music no one's heard of
This module enables Emacs to be used as a music player. It uses mpd as a backend server and mpc to update your music database.
*leave* Emacs!? You must be joking
This module adds system-wide popup Emacs windows for quick edits.
How neckbeards socialize
This module turns Emacs into an IRC client, capable of OS notifications.
An RSS reader that Google can't shut down
Read RSS feeds in the comfort of Emacs.
Be superficial in plain text
Enjoy twitter from emacs.
- View various timelines side by side, e.g. user’s timeline, home, etc.
- Post new tweets
- Send direct messages
- Retweet
- Follow and un-follow users
- Favorite tweets
For modules dedicated to linting plain text (primarily code and prose).
Tasing grammar mistake every you make
This module adds grammar checking to Emacs to aid your writing by combining doom-package:lang-tool and doom-package:writegood-mode.
Tasing you for misspelling mispelling
This modules provides spellchecking powered by aspell, hunspell or
enchant.
Spellcheck is automatically loaded in many text-mode derivatives, which
includes org-mode, markdown-mode, the Git Commit buffer (from magit),
mu4e-compose-mode, and others.
- Spell checking and correction using
aspell,hunspellorenchant. - Ignores source code inside org or markdown files.
- Lazily spellchecking recent changes only when idle.
- Choosing suggestions using completion interfaces (doom-package:ivy or doom-package:helm).
Tasing you for every semicolon you forget
This module provides syntax checking and error highlighting, powered by doom-package:flycheck.
These modules provide interfaces and frameworks completion, including code completion.
The ultimate code completion backend
This module provides code completion, powered by company-mode. Many of Doom’s doom-module::lang modules require it for “intellisense” functionality.
https://assets.doomemacs.org/completion/company/overlay.png
A tank for hunting a house fly
This module provides Helm integration for a variety of Emacs commands, as well as a unified interface for project search and replace, powered by Ripgrep.
A foil for other search engines
Interactive DO things. The completion engine that is mostly built-into Emacs.
Yesterday's lightest search engine
This module provides Ivy integration for a variety of Emacs commands, as well as a unified interface for project search and replace, powered by ripgrep.
I prefer ivy over ido for its flexibility. I prefer ivy over helm because it’s lighter, simpler and faster in many cases.
Tomorrow's search engine
This module enhances the Emacs search and completion experience, and also provides a united interface for project search and replace, powered by ripgrep.
It does this with several modular packages focused on enhancing the built-in
completing-read interface, rather than replacing it with a parallel ecosystem
like doom-package:ivy and doom-package:helm do. The primary packages are:
- Vertico, which provides the vertical completion user interface
- Consult, which provides a suite of useful commands using
completing-read - Embark, which provides a set of minibuffer actions
- Marginalia, which provides annotations to completion candidates
- Orderless, which provides better filtering methods
Modules in this category provide sane defaults or improve your ability to configure Emacs. It is best to load these last.
Reasonable defaults for reasonable people
This module provides a set of reasonable defaults, including:
- A Spacemacs-inspired keybinding scheme
- A configuration for (almost) universally repeating searches with ; and ,
- A doom-package:smartparens configuration for smart completion of certain delimiters, like
/* */command blocks in C-languages,<?php ?>tags in PHP, ordef endin Ruby/Crystal/etc.
Disguise your config as poor documentation
This module enables support for a literate config.
A literate config consists of a $DOOMDIR/config.org. All src blocks within are
tangled $DOOMDIR/config.el, by default, when $ doom sync is executed.
For modules concerned with the insertion and editing of text. Amen.
The text editor Emacs was missing
This holy module brings the Vim editing model to Emacs.
Fill the void in your empty files
This module adds file templates for blank files, powered by doom-package:yasnippet.
What you can't see won't hurt you
This module marries doom-package:hideshow, doom-package:vimish-fold, and outline-minor-mode to bring you
marker, indent and syntax-based code folding for as many languages as possible.
Standardize your ugly code
This module integrates code formatters into Emacs. Here are some of the formatters that it currently supports:
asmfmt, black, brittany, cabal-fmt, clang-format, cmake-format, dartfmt, dfmt, dhall format, dockfmt, elm-format, emacs, fish_indent, fprettify, gleam format, gofmt, iStyle, jsonnetfmt, ktlint, latexindent, ledger-mode, lua-fmt, mix format, nixfmt, node-cljfmt, ocp-indent, perltidy, prettier, purty, rufo, rustfmt, scalafmt, script shfmt, snakefmt, sqlformat, styler, swiftformat, tidy
IDDQD
Adds doom-package:god-mode support to Doom Emacs, allowing for entering commands without modifier keys, similar to Vim’s modality, separating command mode and insert mode.
Vim for lisp, for people who don't like vim
This module adds a keybind scheme for navigating and editing S-expressions in Lisps; including S-exp awareness for Evil users. This affects the following languages:
Make all your mistakes at once
This module adds a multiple cursors implementation to Emacs (two, if you use evil) that loosely take after multi-cursors in Atom or Sublime Text.
Text object editing for the innocent
This modules adds doom-package:objed, a global minor-mode for navigating and manipulating
text objects. It combines the ideas of versor-mode and other editors like Vim
or Kakoune and tries to align them with regular Emacs conventions.
See the objed project README for information on keybinds and usage.
For lispers that like Python more (i.e. nobody)
Parinfer is a minor mode that aids the writing of Lisp code. It automatically infers parenthesis matching and indentation alignment, keeping your code balanced and beautiful.
The only back'n'forth nerds will ever know
This module adds text rotation to Doom Emacs. I.e. The ability to cycle through
keywords or text patterns at point, like true and false, or public,
protected, and private (in c++-mode).
My elves type so I don't have to
This module adds snippet expansions to Emacs, powered by doom-package:yasnippet.
Soft-wrapping with language-aware indent
This module adds a minor-mode fn:+word-wrap-mode, which intelligently wraps long lines in the buffer without modifying the buffer content.
Modules in this category augment and extend the built-in features of Emacs.
Making dired pretty [functional]
This module provides reasonable defaults and augmentations for dired.
Shocking keyword-based electric-indent
This module augments the built-in doom-package:electric package with keyword-based indentation (as opposed to character-based).
Edit me like one of your French buffers
This module augments the built-in doom-package:ibuffer package.
- Adds project-based grouping of buffers
- Support for file-type icons
- Uses human-readable file-size
(No description)
Persistent, smarter undo for your inevitable mistakes
This module augments Emacs’ built-in undo system to be more intuitive and to persist across Emacs sessions.
Be the difference you want to see in the fringe
This module augments Emacs builtin version control support and provides better
integration with git.
Modules that turn Emacs in an email client.
The great filter Hanson hadn't anticipated
This module makes Emacs an email client, using mu4e.
- Tidied mu4e headers view, with flags from doom-package:nerd-icons.
- Consistent coloring of reply depths (across compose and gnus modes).
- Prettified
mu4e:mainview. - Cooperative locking of the
muprocess. Another Emacs instance may request access, or grab the lock when it’s available. - doom-package:org-msg integration with doom-module:+org, which can be toggled per-message, with revamped style and an accent color.
- Gmail integrations with the doom-module:+gmail flag.
- Email notifications with doom-package:mu4e-alert, and (on Linux) a customised notification style.
💡 I want to live in Emacs, but as we all know, living is incomplete without email. So I prayed to the text editor gods and they (I) answered. Emacs+evil’s editing combined with org-mode for writing emails? Yes please.
It uses
mu4eto read my email, but depends onofflineimap(to sync my email via IMAP) andmu(to index my mail into a formatmu4ecan understand).
Closest Emacs will ever be to multi-threaded
This module turns Emacs into an email client using doom-package:notmuch.
To boldly go where no mail has gone before
🔨 This module has no description. Write one?
Modules in this category extend Emacs support for additional keyboard layouts and input methods for non-English languages.
Spend your 3 hours a week in Emacs
This module adds support for traditional Chinese script by introducing two input methods: Pinyin and Wubi.
Ah, a man of culture
This module adds support for Japanese script.
auie,ctsrnm is the superior home row
This module provides barebones support for using Doom with non-qwerty keyboard layouts.
These modules specialize in integration particular languages and their ecosystems into (Doom) Emacs.
Types of types of types of types...
This module adds support for the agda programming language. The Emacs support exists directly in the agda repository, but not in melpa.
Mind the GAAP
This module adds support for Beancount to Emacs. Beancount, like ledger, lets you manage your money in plain text.
C > C++ == 1
This module adds support for the C-family of languages: C, C++, and Objective-C.
- Code completion (
company-irony) - eldoc support (
irony-eldoc) - Syntax-checking (
flycheck-irony) - Code navigation (
rtags) - File Templates (c-mode, c++-mode)
- Snippets (cc-mode, c-mode, c++-mode)
- Several improvements to C++11 indentation and syntax highlighting.
Java with a lisp
This module adds support for the Clojure(Script) language.
- Interactive development environment (
cider): REPL, compilation, debugging, running tests, definitions & documentation lookup, code completion, and much more - Refactoring (
clj-refactor) - Linting (
clj-kondo), requires:checkers syntax - LSP support (
clojure-lsp)
If you've seen one lisp, you've seen them all
This module provides support for Common Lisp and the doom-package:Sly development environment. Common Lisp is not a single language but a specification, with many competing compiler implementations. By default, Steel Bank Common Lisp (SBCL) is assumed to be installed, but this can be configured.
Common Lisp benefits from a mature specification and rich standard library. Thanks to its powerful REPL and debugger, it boasts an “interactive programming” style often unseen in other languages. Compiled Common Lisp programs are trusted to run unmodified for a long time.
Proofs as programs
This module adds coq support, powered by Proof General.
- Code completion (company-coq)
- Snippets
Ruby at the speed of C
This modules adds crystal support.
- Syntax-checking (
flycheck) - REPL (
inf-crystal)
Unity, .NET, and Mono shenanigans
This module adds C# support to Emacs, powered by Omnisharp (directly or through LSP).
Paint ui and not much else
Dart is a client-optimized language by Google for fast apps on any platform. It is fast and optimized for UI, famous for the Flutter framework, also made by Google. Both Flutter and Dart are free and open-source.
This module wraps dart-mode, with LSP features like code completion for
.dart files, syntax highlighting, debugging, closing labels, etc.
A dumping ground for data formats
This module adds Emacs support for CSV and XML files.
Config as code
This module adds Dhall language support to Emacs.
Dhall is a programmable configuration language that you can think of as: JSON + functions + types + imports.
Erlang done right
This module provides support for Elixir programming language via doom-package:alchemist or elixir-ls.
Care for a cup of TEA?
This module adds Elm support to Doom Emacs.
A parsel-tongue for the oldest serpent
This module extends support for Emacs Lisp in Doom Emacs.
- Macro expansion
- Go-to-definitions or references functionality
- Syntax highlighting for defined and quoted symbols
- Replaces the built-in help with the more powerful doom-package:helpful
- Adds function example uses to documentation
An elegant language for a more civilized age
This module provides support Erlang programming language. Support for the sourcer language server is optional.
Includes:
- Code completion (doom-module:+lsp, doom-module::completion company, & doom-module::completion ivy)
- Syntax checking (doom-module::checkers syntax)
73.6% of all statistics are made up
This module adds support for various statistics languages, including R, S-Plus, SAS, Julia and Stata.
...
This module adds support to the factor programming language and its associated doom-package:fuel emacs plugin.
DSP, but you can keep your soul
Add support to Faust language inside emacs.
- Faust code syntax highlighting and indentation
- Project-based (inter-linked Faust files)
- Build/compile with output window
- Graphic diagrams generation and visualization in the (default) browser
- Browse generated C++ code inside Emacs
- Inter-linked files/buffers :
- From “component” to Faust file
- From “include” to Faust library file
- From error to file:line number
- From function name to online documentation
- Fully configurable (build type/target/architecture/toolkit, keyboard shortcuts, etc.)
- Automatic keyword completion (if Auto-Complete is installed)
- Automatic objets (functions, operators, etc.) template insertion with default sensible values (if doom-module::editor snippets is enabled)
- Modeline indicator of the state of the code
ML stands for Microsoft's Language
This module adds F# support to Doom Emacs.
(Dependent) types and (monadic) effects and Z3
This module adds F* support, powered by fstar-mode.el.
- Syntax highlighting
- Interactively process F* files one definition at a time
- Query the running F* process to look up definitions, documentation, and theorems
the language you waited for
This module adds support for GDScript, the scripting language of the Godot game engine, to Doom Emacs, powered by gdscript-mode.
The hipster dialect
This module adds Go support, with optional (but recommended) LSP support via gopls.
- Code completion (
gocode) - Documentation lookup (
godoc) - Eldoc support (
go-eldoc) - REPL (
gore) - Syntax-checking (
flycheck) - Auto-formatting on save (
gofmt) (requires doom-module::editor format +onsave) - Code navigation & refactoring (
go-guru) - File templates
- Snippets
- Generate testing code (
go-gen-test) - Code checking (
flycheck-golangci-lint)
A language that's lazier than I am
This module adds Haskell support to Doom Emacs.
Lisp is better than ugly
(No description yet)
A language you can depend on
This module adds rudimentary Idris support to Doom Emacs.
The poster child for carpal tunnel syndrome
This module adds Java support to Doom Emacs, including android-mode and
groovy-mode.
all(hope(abandon(ye(who(enter(here))))))
This module adds JavaScript and TypeScript support to Doom Emacs.
- Code completion (doom-package:tide)
- REPL support (doom-package:nodejs-repl)
- Refactoring commands (doom-package:js2-refactor)
- Syntax checking (doom-package:flycheck)
- Browser code injection with doom-package:skewer-mode
- Coffeescript & JSX support
- Jump-to-definitions and references support (doom-package:xref)
At least it ain't XML
This module adds JSON support to Doom Emacs.
A better, faster MATLAB
This module adds support for the Julia language to Doom Emacs.
- Syntax highlighting and latex symbols from doom-package:julia-mode
- REPL integration from doom-package:julia-repl
- Code completion and syntax checking, requires doom-module::tools lsp and doom-module:+lsp
A Java(Script) that won't depress you
This module adds Kotlin support to Doom Emacs.
Writing papers in Emacs has never been so fun
Provide a helping hand when working with LaTeX documents.
- Sane defaults
- Fontification of many popular commands
- Pretty indentation of wrapped lines using the doom-package:adaptive-wrap package
- Spell checking with doom-package:flycheck
- Change PDF viewer to Okular or doom-package:latex-preview-pane
- Bibtex editor
- Autocompletion using doom-package:company-mode
- Compile your
.texcode only once using LatexMk
For folks with too much to prove
This module adds support for the Lean programming language to Doom Emacs.
Be audit you can be
This module adds support for ledger files. Ledger is a command line double-entry accounting system that works with simple text files holding transactions in the following format:
2015/10/12 Exxon
Expenses:Auto:Gas $10.00
Liabilities:MasterCard $-10.00
This modules enables the following features:
- Syntax and indentation support for ledger files
- Add, edit, and delete transactions
- Generate reports
- Schedule transactions
- Sort transactions
- Display statistics about transactions
- Display balance up to a point
One-based indices? one-based indices
This module adds Lua support to Doom Emacs.
- REPL
- Love2D specific functions
- Moonscript support
- Fennel support
Write docs for people to ignore
This module provides Markdown support for Emacs.
Markdown is a text-to-HTML conversion tool for web writers. Markdown allows you to write using an easy-to-read, easy-to-write plain text format, then convert it to structurally valid XHTML (or HTML).
Thus, “Markdown” is two things: (1) a plain text formatting syntax; and (2) a software tool, written in Perl, that converts the plain text formatting to HTML. See the Syntax page for details pertaining to Markdown’s formatting syntax. You can try it out, right now, using the online Dingus.
The overriding design goal for Markdown’s formatting syntax is to make it as readable as possible. The idea is that a Markdown-formatted document should be publishable as-is, as plain text, without looking like it’s been marked up with tags or formatting instructions. While Markdown’s syntax has been influenced by several existing text-to-HTML filters, the single biggest source of inspiration for Markdown’s syntax is the format of plain text email. – John Gruber
Python + lisp at the speed of C
This module adds Nim support to Doom Emacs.
- Code completion (doom-package:nimsuggest + doom-package:company)
- Syntax checking (doom-package:nimsuggest + doom-package:flycheck)
- Org babel support (doom-package:ob-nim)
I hereby declare "nix geht mehr!"
This module adds support for the Nix language to Doom Emacs, along with tools for managing Nix(OS).
Includes:
- Syntax highlighting
- Completion through doom-package:company and/or doom-package:helm
- Nix option lookup
- Formatting (
nixfmt)
An objective camel
This module adds OCaml support to Doom Emacs, powered by doom-package:tuareg-mode.
- Code completion, documentation look-up, code navigation and refactoring (doom-package:merlin)
- Type, documentation and function argument display on idle (doom-package:merlin-eldoc)
- REPL (doom-package:utop)
- Syntax-checking (doom-package:merlin with doom-package:flycheck-ocaml)
- Auto-indentation (doom-package:ocp-indent)
- Code formatting (doom-package:ocamlformat)
- Dune file format (doom-package:dune)
org: +brain +dragndrop +gnuplot +hugo +ipython +journal +jupyter +noter +pandoc +pomodoro +present +pretty +roam +roam2
Organize your plain life in plain text
This module adds org-mode support to Doom Emacs, along with a number of adjustments, extensions and reasonable defaults to make it more performant and intuitive out of the box:
- A custom, centralized attachment system that stores files in one place, rather
than in the same directory as the input file(s) (only applies to attachments
from files in/under
org-directory). - Executable code blocks with support for a variety of languages and tools (depending on what :lang modules are enabled).
- Supports an external org-capture workflow through the
bin/org-captureshell script and+org-capture/open-frame. - A configuration for using org-mode for slide-show presentations or exporting org files to reveal.js slideshows.
- Drag-and-drop support for images (with inline preview) and media files (drops a file icon and a short link) (requires doom-module:+dragndrop flag).
- Integration with pandoc, ipython, jupyter, reveal.js, beamer, and others (requires flags).
- Export-to-clipboard functionality, for copying text into formatted html,
markdown or rich text to the clipboard (see
+org/export-to-clipboardand+org/export-to-clipboard-as-rich-text).
Org is a system for writing plain text notes with syntax highlighting, code execution, task scheduling, agenda management, and many more. The whole idea is that you can write notes and mix them with references to things like articles, images, and example code combined with the output of that code after it is executed.
https://www.mfoot.com/blog/2015/11/22/literate-emacs-configuration-with-org-mode/
Perl's insecure younger brother
This module adds support for PHP 5.3+ (including PHP7) to Doom Emacs.
- ctags-based code completion (
company-phpandphpctags) - eldoc support (
ac-phpandphp-extras) - REPL (
php-boris) - Code refactoring commands (
php-refactor-mode) - Unit-test commands (
phpunit) - Support for
laravelandcomposerprojects (with project-specific snippets) - File templates
- Snippets
💡 PHP was the first programming language I got paid to code in, back in the Cretaceous period (2003). My sincerest apologies go out to all the programmers who inherited my earliest PHP work. I know you’re out there, writhing in your straitjackets.
Save a programmer today. Stop a friend from choosing PHP as their first language.
Diagrams to confuse people more
This module adds plantuml support to Emacs; allowing you to generate diagrams from plain text.
Javascript, but functional
This module adds Purescript support to Doom Emacs.
Beautiful is better than ugly
This module adds Python support to Doom Emacs.
- Syntax checking (doom-package:flycheck)
- Snippets
- Run tests (doom-package:nose, doom-package:pytest)
- Auto-format (with
black, requires doom-module::editor format) - LSP integration (
mspyls,pyls, orpyright)
The cutest GUI framework ever
This module provides language functionality for Qt specific files.
The DSL for DSLs
This module adds support for the Racket programming language to Doom Emacs.
The artist formerly known as perl6
This module adds support for the Raku programming language to Doom Emacs.
Emacs as a REST client
This module turns Emacs into a REST client.
- Code-completion (
company-restclient) - Code evaluation
- Imenu support for
restclient-mode - org-mode: babel support (
ob-restclient)
💡
restclient-modeis tremendously useful for automated or quick testing REST APIs. My workflow is to open anorg-modebuffer, create a restclient source block and hack away.restclient-modeandcompany-restclientpower this arcane wizardry.
ReST in peace
This module adds ReStructured Text support to Doom Emacs.
1.step {|i| p "Ruby is #{i.even? ? 'love' : 'life'}"}
This module add Ruby and optional Ruby on Rails support to Emacs.
- Code completion (doom-package:robe)
- Syntax checking (doom-package:flycheck)
- Jump-to-definitions (doom-package:robe)
- Bundler
- Rubocop integration (doom-package:flycheck)
Fe2O3.unwrap().unwrap().unwrap().unwrap()
This module adds support for the Rust language and integration for its tools,
e.g. cargo.
- Code completion (doom-package:racer or an LSP server)
- Syntax checking (doom-package:flycheck)
- LSP support (for rust-analyzer and rls) (doom-package:rustic)
- Snippets
Java, but good
This module adds scala and sbt support to Doom Emacs.
Through the power of Metals (LSP) this module offers:
- Goto Definition
- Completions
- Hover
- Paremeter Hints
- Find References
- Run/Debug
- Find Implementations
- Rename Symbol
- Code Actions
- Document Symbols
- Formatting
- Folding
- Organize Imports
A fully conniving family of lisps
This module provides support for the Scheme family of Lisp languages, powered by geiser.
She sells {ba,z,fi}sh shells on the C xor
This module adds support for shell scripting languages (including Powershell and Fish script) to Doom Emacs.
- Code completion (doom-package:company-shell)
- Syntax Checking (doom-package:flycheck)
...
THis module adds SML (Standard ML) programming language support to Doom Emacs.
Do you need a blockchain? No.
This module adds Solidity support to Doom Emacs.
- Syntax-checking (doom-package:flycheck)
- Code completion (doom-package:company-solidity)
- Gas estimation (
C-c C-g)
We asked for emoji variables?
This module adds support for the Swift programming language to Doom Emacs.
Earth and Moon in alignment for performance.
(No description)
The tubes
This module adds support for various web languages, including HTML5, CSS, SASS/SCSS, Pug/Jade/Slim, and HAML, as well as various web frameworks, like ReactJS, Wordpress, Jekyll, Phaser, AngularJS, Djano, and more.
JSON, but readable
This module provides support for the YAML file format to Doom Emacs.
C, but simpler
This module adds Zig support, with optional (but recommended) LSP support via zls.
- Syntax highlighting
- Syntax-checking (doom-package:flycheck)
- Code completion and LSP integration (
zls)
Modules in this category are designed to improve compatibility with certain operating systems or OS features (like the shell).
Compatibility for our favorite walled garden
This module provides extra functionality for macOS.
Make TTY Emacs suck less
This module configures Emacs for use in the terminal, by providing:
- System clipboard integration (through an external clipboard program or OSC-52 escape codes in supported terminals).
- Cursor-shape changing across evil states (requires a terminal that supports it).
- Mouse support in the terminal.
What’s an operating system without a terminal? The modules in this category bring varying degrees of terminal emulation into Emacs.
If you can’t decide which to choose, I recommend doom-package:vterm or doom-package:eshell. doom-module::term vterm offers that best terminal emulation available but requires a few extra steps to get going. doom-module::term eshell works everywhere that Emacs runs, even Windows, and provides a shell entirely implemented in Emacs Lisp.
The elisp shell that works everywhere
This module provides additional features for the built-in Emacs Shell
The Emacs Shell or doom-package:eshell is a shell-like command interpreter implemented in
Emacs Lisp. It is an alternative to traditional shells such as bash, zsh,
fish, etc. that is built into Emacs and entirely cross-platform.
A REPL for your shell
Provides a REPL for your shell.
💡
shellis more REPL than terminal emulator. You can edit your command line like you would any ordinary text in Emacs – something you can’t do in doom-package:term (withoutterm-line-mode, which can be unstable) or doom-package:vterm.Due to
shell’s simplicity, you’re less likely to encounter edge cases (e.g. against your shell config), but it’s also the least capable. TUI programs likehtoporvimwon’t work in shell directly, but will be launched in atermbuffer – which handles them reasonably well.
It's terminal
(No description)
As good as terminal emulation gets in Emacs
This module provides a terminal emulator powered by libvterm. It is still in
alpha and requires a component be compiled (vterm-module.so).
💡 doom-package:vterm is as good as terminal emulation gets in Emacs (at the time of writing) and the most performant, as it is implemented in C. However, it requires extra steps to set up:
- Emacs must be built with dynamic modules support,
- and
vterm-module.somust be compiled, which depends onlibvterm,cmake, andlibtool-bin.doom-package:vterm will try to automatically build
vterm-module.sowhen you first open it, but this will fail on Windows, NixOS and Guix out of the box. Install instructions for nix/guix can be found in the doom-module::term vterm module’s documentation. There is no way to install vterm on Windows that I’m aware of (but perhaps with WSL?).
Modules that integrate external tools into Emacs.
Allow silly people to focus on silly things
(No description)
(No description)
Step through code to help you add bugs
Introduces a code debugger to Emacs, powered by doom-package:realgud or doom-package:dap-mode (LSP).
This document will help you to configure doom-package:dap-mode Native Debug(GDB/LLDB) as there is still not enough documentation for it.
Save (or destroy) the environment at your leisure
This module integrates direnv into Emacs.
📌 direnv is an environment switcher for the shell. It knows how to hook into bash, zsh, tcsh, fish shell and elvish to load or unload environment variables depending on the current directory. This allows project-specific environment variables without cluttering the ~/.profile file.
Before each prompt, direnv checks for the existence of a “.envrc” file in the current and parent directories. If the file exists (and is authorized), it is loaded into a bash sub-shell and all exported variables are then captured by direnv and then made available to the current shell.
Yo dawg, I heard you like OSes, so I…
This module allows you to manipulate Docker images, containers, and more from Emacs.
Provides a major dockerfile-mode to edit Dockerfiles. Additional convenience
functions allow images to be built easily.
doom-package:docker-tramp offers TRAMP support for Docker containers.
Let someone else argue tabs and spaces
This module integrates EditorConfig into Emacs, allowing users to dictate code
style on a per-project basis with an .editorconfig file (formal
specification).
Tame Jupyter notebooks with emacs
Adds Jupyter notebook integration into Emacs.
Run code, run (also, repls)
This modules adds inline code evaluation support to Emacs and a universal interface for opening and interacting with REPLs.
A pastebin for Githubsters
Adds the ability to manage, pull from, or push to your Gists from within Emacs.
Navigate your labyrinthine code and docs
This module adds code navigation and documentation lookup tools to help you quickly look up definitions, references, documentation, dictionary definitions or synonyms.
- Jump-to-definition and find-references implementations that just work.
- Powerful xref integration for languages that support it.
- Search online providers like devdocs.io, stackoverflow, google, duckduckgo, or youtube (duckduckgo and google have live suggestions).
- Integration with Dash.app docsets.
- Support for online (and offline) dictionaries and thesauruses.
M-x vscode
This module integrates language servers into Doom Emacs. They provide features you’d expect from IDEs, like code completion, realtime linting, language-aware doom-package:imenu/doom-package:xref integration, jump-to-definition/references support, and more.
As of this writing, this is the state of LSP support in Doom Emacs:
| Module | Major modes | Default language server |
|---|---|---|
| doom-module::lang cc | c-mode, c++-mode, objc-mode | ccls, clangd |
| doom-module::lang clojure | clojure-mode | clojure-lsp |
| doom-module::lang csharp | csharp-mode | omnisharp |
| doom-module::lang elixir | elixir-mode | elixir-ls |
| doom-module::lang fsharp | fsharp-mode | Mono, .NET core |
| doom-module::lang go | go-mode | go-langserver |
| doom-module::lang haskell | haskell-mode | haskell-language-server |
| doom-module::lang java | java-mode | lsp-java |
| doom-module::lang javascript | js2-mode, rjsx-mode, typescript-mode | ts-ls, deno-ls |
| doom-module::lang julia | julia-mode | LanguageServer.jl |
| doom-module::lang ocaml | tuareg-mode | ocaml-language-server |
| doom-module::lang php | php-mode | php-language-server |
| doom-module::lang purescript | purescript-mode | purescript-language-server |
| doom-module::lang python | python-mode | lsp-python-ms |
| doom-module::lang ruby | ruby-mode | solargraph |
| doom-module::lang rust | rust-mode | rls |
| doom-module::lang scala | scala-mode | metals |
| doom-module::lang sh | sh-mode | bash-language-server |
| doom-module::lang swift | swift-mode | sourcekit |
| doom-module::lang web | web-mode, css-mode, scss-mode, sass-mode, less-css-mode | vscode-css-languageserver-bin, vscode-html-languageserver-bin |
| doom-module::lang zig | zig-mode | zls |
Wield git like a wizard
This module provides Magit, an interface to the Git version control system.
The discount build system
This module adds commands for executing Makefile targets.
A password manager for nerds
This module provides an Emacs interface to Pass.
Emacs, your next PDF reader
This module improves support for reading and interacting with PDF files in Emacs.
It uses doom-package:pdf-tools, which is a replacement for the built-in doc-view-mode for
PDF files. The key difference being pages are not pre-rendered, but instead
rendered on-demand and stored in memory; a much faster approach, especially for
larger PDFs.
Displaying PDF files is just one function of doom-package:pdf-tools. See its project website for details and videos.
No sweatshop is complete without child processes
This module provides an interface for managing external services from within Emacs.
Creating color strings
Highlights color hex values and names with the color itself, and provides tools to easily modify color values or formats.
Taskrunner for all your projects
This module integrates doom-package:taskrunner into Doom Emacs, which scraps runnable tasks from build systems like make, gradle, npm and the like.
Infrastructure as code
This module adds support for working with Terraform files within Emacs. This includes syntax highlighting, intelligent code completion, and the ability to run Terraform commands directly from Emacs.
From one multiplexer to another
This module provides an API for talking to Tmux sessions.
Map local directories to remotes via ssh/ftp
Uses ssh-deploy to map a local folder to a remote one.
From the ssh-deploy README:
The ssh-deploy plug-in for Emacs makes it possible to effortlessly deploy local files and directories to remote hosts via Tramp (including but not limited to SSH, SFTP, FTP). It tries to provide functions that can be easily used by custom scripts.
The idea for this plug-in was to mimic the behavior of PhpStorm deployment functionality.
For modules concerned with changing Emacs’ appearance or providing interfaces for its features, like sidebars, tabs, or fonts.
Notational velocity for Emacs
Deft is a major mode for creating, browsing, and filtering notes written in plain text formats, such as org-mode, markdown, and LaTeX. It enables you to quickly jot down thoughts and easily retrieve them later.
Make Doom fabulous again
This module gives Doom its signature look: powered by the doom-one theme (loosely inspired by Atom’s One Dark theme) and doom-package:solaire-mode. Includes:
- A custom folded-region indicator for doom-package:hideshow.
- “Thin bar” fringe bitmaps for doom-package:git-gutter-fringe.
- File-visiting buffers are slightly brighter (thanks to doom-package:solaire-mode).
Welcome to your doom
This module adds a minimalistic, Atom-inspired dashboard to Emacs.
Besides eye candy, the dashboard serves two other purposes:
- To improve Doom’s startup times (the dashboard is lighter than the scratch buffer in many cases).
- And to preserve the “last open directory” you were in. Occasionally, I kill
the last buffer in my project and I end up who-knows-where (in the working
directory of another buffer/project). It can take some work to find my way
back to where I was. Not with the Dashboard.
Since the dashboard cannot be killed, and it remembers the working directory of the last open buffer,
M-x find-filewill work from the directory I expect.
One does not simply quit Emacs
A silly module that throws cute confirmation prompts at you when you exit Emacs, like DOOM (the game) did. Some quotes are from the classic games, others are random, nerdy references that no decent human being has any business recognizing.
💩
This module gives Emacs the ability to display and insert emojis (ASCII, Github
style, or unicode styles), as well as convert certain text patterns (e.g.
:smile:) into emojis.
TODO FIXME NOTE DEPRECATED HACK REVIEW
This module adds syntax highlighting for various tags in code comments, such as
TODO, FIXME, and NOTE, among others.
Discount modality for mythological beast hunters
This module adds hydra to Doom Emacs, as well as a few custom built hydras to start with:
- A hydra to control windows
+hydra/window-nav/body. - A hydra to control text zoom level
+hydra/text-zoom/body.
Line up them indent columns
(No description)
Distract folks from your code
This module enables ligatures and arbitrary symbol substitutions with
mac-auto-operator-composition-mode (on supported macOS systems) or composition
tables (harfbuzz on Emacs 28), falling back on prettify-symbols-mode
otherwise.
A map for lost programmers
This module displays a minimap of the buffer in a sidebar, similar to the feature found in many other editors.
Snazzy, Atom-inspired modeline, plus API
This module provides an Atom-inspired, minimalistic modeline for Doom Emacs, powered by the doom-package:doom-modeline package (where you can find screenshots).
Blink after big motions
This module flashes the line around the cursor after any significant motion, to make it easy to follow after big operations.
💡 Tremendously helpful on large, 1600p+ or 4K displays.
NERDTree for evil nerds
This module brings a side panel for browsing project files, inspired by vim’s NERDTree.
💡 Sure, there’s doom-package:dired and doom-package:projectile, but sometimes I’d like a bird’s eye view of a project.
An indicator for “what did I just do?”
This module provides op-hints (operation hinting), i.e. visual feedback for certain operations. It highlights regions of text that the last operation (like yank) acted on.
Uses doom-package:evil-goggles for evil users and doom-package:volatile-highlights otherwise.
Tame sudden yet inevitable temporary windows
This module provides a customizable popup window management system.
Not all windows are created equally. Some are less important. Some I want gone once they have served their purpose, like code output or a help buffer. Others I want to stick around, like a scratch buffer or org-capture popup.
More than that, popups ought to be the second class citizens of my editor; spawned off to the side, discarded with the push of a button (e.g. ESC or C-g), and easily restored if I want to see them again. Of course, this system should clean up after itself and kill off buffers I mark as transient.
Keep tabs on your buffers, literally
This module adds an Atom-esque tab bar to the Emacs UI.
A sidebar for all the things
Treemacs is a file and project explorer similar to NeoTree or vim’s NerdTree, but largely inspired by the Project Explorer in Eclipse. It shows the file system outlines of your projects in a simple tree layout allowing quick navigation and exploration, while also possessing basic file management utilities. It includes:
- Integration with Git (if doom-module::tools magit is enabled)
- Integration with Evil (if doom-module::editor evil +everywhere is enabled)
- Workspace awareness (if doom-module::ui workspaces is enabled)
Extended unicode support for various languages
This module extends Doom’s ability to display non-English unicode. It is primarily useful for non-English Emacs users, for whom Doom’s built-in unicode support in insufficient.
This module relies on the unicode-fonts package. It tries to setup the default emacs fontset to cover as many unicode glyphs as possible by scanning all available glyphs from all available fonts.
When this module is enabled:
- Emacs will prefer to use the
doom-symbol-fontfont to display non-latin glyphs if it provides coverage for them. - The first time you run Emacs a unicode cache will be generated – this will take a while!
- The cache will be regenerated every time Emacs is made aware of new fonts or
you change the font configuration e.g. by modifying
doom-symbol-font. - The cache will be stored and should not be regenerated unless font-related configuration or the versions of relevant packages changes.
Get your diff out of the gutter
This module displays a diff of the current file (against HEAD) in the fringe. Supports Git, Svn, Hg, and Bzr.
Fringe tildes beyond EOB
Displays a tilde(~) in the left fringe to indicate an empty line, similar to Vi.
Visually switch windows
This module provides several methods for selecting windows without the use of the mouse or spatial navigation (e.g. C-w {h,j,k,l}).
The command other-window is remapped to either doom-package:switch-window or doom-package:ace-window,
depending on which backend you’ve enabled. It is bound to C-x o (and C-w C-w for
evil users).
It also provides numbered windows and selection with the doom-package:winum package, if desired. Evil users can jump to window N in C-w <N> (where N is a number between 0 and 9). Non evil users have C-x w <N> instead.
Tab emulation, persistence, & separate workspaces
This module adds support for workspaces, powered by doom-package:persp-mode, as well as a API for manipulating them.
💡 There are many ways to use workspaces. I spawn a workspace per task. Say I’m working in the main workspace, when I realize there is a bug in another part of my project. I open a new workspace and deal with it in there. In the meantime, I need to check my email, so mu4e gets its own workspace.
Once I’ve completed the task, I close the workspace and return to main.
Distraction-free mode for the eternally distracted
This module provides two minor modes that make Emacs into a more comfortable writing or coding environment. Folks familiar with “distraction-free” or “zen” modes from other editors – or doom-package:olivetti, doom-package:sublimity, and doom-package:tabula-rasa (Emacs plugins) – will feel right at home.
These modes are:
mixed-pitch-mode-
Which renders (most) text in a variable pitch font (see
doom-variable-pitch-font). Unlikevariable-pitch-mode, this will not affect segments of text that are intended to remain in a fixed pitch font, such as code blocks or ASCII tables. writeroom-mode-
Our all-in-one “zen” mode that will:
- Center the current buffer.
- Remove superfluous UI elements (like the modeline).
- Activate
mixed-pitch-mode. - Scale up the buffer’s text slightly (see
+zen-text-scale). - And make the window’s borders slightly thicker (see
+zen-window-divider-size).