• Tired of writing Emacs configuration code? 🤯
• Afraid of or ever declared .emacs bankruptcy? 😰
• Don't want to spend your time writing Emacs Lisp code? 😳 [1]
• Need to quickly access help now and later on specific topic? 🤔
• Want to learn Emacs and try several built-in and external packages? 😇
• Want to run independent Emacs sessions with fast startup even with a large number of external packages installed? 😃
• And also want to run Emacs daemon(s) with text and graphics clients on Linux and macOS like a pro? 🥳

PEL might be for you! Then go ahead, install it [2] or update it [3] ! Leave feedback in the discussion if you wish.

Essentially PEL extends plain vanilla Emacs and provides:

• Unified, Cohesive Command Interface: with 729 additional key-bound commands, several of which provide glue logic between features to increase cohesion and simplify usage.

• Extended Vanilla Emacs Key Bindings keeps the vanilla Emacs key bindings with a large set of extra key bindings using function key prefixes and instructions on how to activate them on macOS and several Linux distros.

  • Supports Emacs in terminal mode, providing terminal key bindings for commands that normally do not have them.
  • Supports Emacs in graphical mode with some extensions specific to macOS and Linux.
  • Attempts to provide a globally unified keyboard experience for a large set of commands across multiple major modes.

• Useful Hydras enhance keyboard navigation and editing efficiency further.

  • See ➣ PEL Convenience Commands below.

• Zero-Code Configuration via customization that identifies used packages and their settings.

  • No Emacs Lisp coding required — all PEL and Emacs features, package activation, and configuration are driven entirely by Emacs' built-in customization UI.
  • Allows independent configuration of terminal-based and GUI-based Emacs customization to prevent slowing down terminal mode with logic that is only available in graphical mode.
  • This makes it trivial to maintain various specialized workspace setups.
  • The customization files can be stored in directories under VCS control to easily keep track of changes and share them across machines.
  • No .emacs bankruptcy risk: your init.el file won't grow over time as information is stored in PEL's logic and inside your customization files.

• Feature Integration/Gradual Use PEL controls installation and configuration of external packages through the various pel-use-... customizable user-options.

  • PEL provides coordination logic that no individual package provides on its own.
  • You can start small by activating only what you need and add more later, or remove something you no longer need, all done through customization; you do not need to write code for that.

• Broad language / major-mode coverage as PEL explicitly supports over 80 programming, markup, hardware description and data description languages as well as build control languages and various other major modes.

  • PEL provides specialized programming language templates to ease file creation like C, C++ and Erlang for example.
  • PEL provides copyright notice and time stamp management.
  • To help you edit files with narrow indentation schemes such as Dart and Gleam files that must use a 2-space indent, PEL integrates my stand-alone tbindent package that provides a minor mode that automatically converts the indentation to tabs-based indentation in the buffer so you can see the code better the way you want 😎.

• Cross-platform Portability supports Linux, macOS and Windows, Emacs 26.3 and later, running under a terminal or GUI as an independent Emacs process or under the Emacs daemon.

  • PEL provides POSIX-compliant shell scripts to launch Emacs within a shell context (with all its environment variables) in the following modes:
    • single process terminal mode: the e command,
    • single process GUI mode: the ge command,
    • daemon Emacs server and clients: the ec command.

• Non-invasive/Safe Design PEL does not monkey patch Emacs.

  • All PEL Emacs Lisp code (including the early-init.el and init.el) is byte and native compiled on all supported Emacs versions on macOS and Linux, and no compilation error or warning is allowed. Note that there is currently no Windows environment in the CI build; I have not found one that is light enough to run for this open-source project.

• Integrates external packages, control their installation by customization. Supports 377 external packages from multiple sources:

  • GNU Elpa and MELPA elpa-compliant sites, quelpa installs from source,
  • GitHub, Gitlab or web-site hosted files not setup as Emacs packages,
  • and you can still install packages with Emacs package management commands, and manually configure them by adding extra logic in the PEL init.el file.

• Emacs Startup Optimization with carefully crafted, byte/native compiled early-init.el, init.el and control logic with aggressive lazy-loading, macro-based deferred execution to maximize speed of independent Emacs processes.

  • See the PEL installation for details.

• Fast Startup Mode: Beyond general startup optimization, PEL provides ahead-of-time byte/native compilation and physical directory restructuring system that squashes Emacs load-path. This speeds up Emacs boot time even more, allowing:

  • sub 0.1 second startups on Linux, and
  • under 0.2 seconds on macOS, even with over 300 packages.

  PEL provides commands to toggle from normal mode to fast startup and back.

• Extensive Code Validation of all Emacs Lisp code through byte and native compilation controlled by GNU Make script which also performs specialized linting, ERT-based unit testing.

  • All are executed on GitHub CI on several supported Emacs versions on Linux and macOS environments (see PEL's GitHub workflow build YAML file).
  • Builds and tests pass only when no error and no warning are detected.
  • PEL has a growing suite of ERT-based test code.
  • PEL has several specialized linting programs that parse elisp code and detect errors that would only be detected at run time under specific conditions.
  • All PEL code is built by a GNU Make script that I use in my systems and on GitHub CI systems under all platforms and supported Emacs versions.

• Dynamic Feature Selection allows selection of minor modes or command behaviour like selecting whether search command uses the standard iSearch, or features from Anzu or Swiper. Same for input and auto completion, cross-reference, etc.

• Extensive Introspection with contextual help commands that describe major mode and minor modes, indentation and hard-tab control, cross-reference control, etc. These contextual commands open specialized help buffers that assemble everything relevant in one place with buttons to quickly access the relevant customizable user-options.

• Flexible Tree-sitter Support

  • Customization-specified selection of whether the Tree-sitter or classic major mode is used for each major mode that supports both.
  • Dynamically switch from classic to Tree-sitter based major mode and back at any time and without any impact on your original selection.
  • See the 🚦 Tree-sitter PDF; it provides information on the tree-sitter language grammars and major modes supporting it.
  • Also see the document titled Using tree-sitter with Emacs and PEL which describes how to setup your environment to use the tree-sitter based modes,

• 221 Extensive Topic-organized Reference PDFs The heavily hyperlinked tables serve as visual, topic-organized key-binding and feature reference sheets, an unusual approach in the Emacs ecosystem which complements Emacs' excellent documentation system.

  • Use the PEL Index PDF to quickly locate a topic.
  • See the Tramp PDF to learn how to use and troubleshoot it.
  • See the Mode Line PDF to see the command that describes Emacs cryptic mode line process and buffer type.
  • See the ➣ Extends Emacs Documentation section for more information.

• Many Command Line Tools comes with PEL: the shell scripts to start Emacs in various ways, build CTags tables, the awk scripts for text filtering and transformation.

  • You may also be interested by my separate USRHOME project to setup your POSIX compliant shells; it is not part nor required to use PEL but provides several useful commands and setup shells for system that you can access with Emacs Tramp.

PEL keeps evolving. I use it to maintain my Emacs configuration on several macOS and Linux systems and also under Windows (whenever I have to use it).

And, using PEL, I can still use other Emacs packages installed under Emacs package management and if I need to use them often in multiple systems I integrate their management under PEL.

If you find PEL useful please drop me a comment, and if you'd like some new features don't hesitate to ask. And if you like what you see why not give this project a star to encourage me further?

Again any feedback is welcome. Thanks!

• PEL supports terminal Emacs launched from a shell and graphics Emacs launched from a shell or a GUI program like Windows Explorer, macOS Finder, Linux file managers, etc.

• Want to start Emacs as an independent process or a text or GUI client to the Emacs daemon? PEL provides simple shell scripts for all of that (for macOS and Linux). See Using the Emacs daemon and clients for more info and the related quick shortcut installation script.

• With PEL, Emacs will start faster than with several other systems; PEL Emacs initialization is heavily optimized to auto-load and defer execution as much as possible. Emacs startup time under a second for a large number of activated package is easily achieved, even on old computers.

  • PEL provides examples of early-init.el and init.el files that must be used to achieve these performances (and faster when fast startup is used).
  • Take a look at some numbers and screen shots in the startup directory:
    • A 0.65 second startup with 433 loaded files on terminal based Emacs 30.2 running on a 2023 macStudio computer and 0.81 seconds for 422 loaded files in graphical Emacs on the same computer. In normal mode that has 333 directories in the load path with 267 elpa packages and 77 Emacs Lisp files stored in the PEL utils directory. The fast startup squashes the load path to 77 directories.
    • A 0.5 seconds startup with 223 packages by PEL on a 2014 imac running Emacs 26.3 terminal (in normal mode),
    • And a 0.1 seconds startup with the same settings on a 2014 imac running Emacs 26.3 terminal in fast-startup mode,
    • On Emacs 30.1 in terminal mode under Rocky Linux 8.10 VM running in a 2014 iMac, accessed via ssh with a GNU screen session. Note this one: it has 412 loaded features, yet the Emacs startup time is 0.5 seconds even if PEL fast startup mode is not used! Emacs is using native compilation mode here, and Emacs also runs faster on Linux than under macOS.
    • On a 2023 macStudio running Emacs 30.1 in terminal (in normal mode, without native compilation), starts in 0.58 seconds while providing 612 features (with 634 loaded files).
    • On a 2023 macStudio running Emacs 30.1 in Graphics mode (in normal-mode, without native compilation).

• You can speed Emacs startup much more with PEL fast startup mode command (see also ⅀ Fast Startup PDF). PEL supports 2 different Emacs startup operation modes:

  • The normal startup mode, using Emacs' standard package.el package manager with PEL's extensions that provide customization-driven package management built on Emacs easy customization to pick and chose packages and behaviours, all without having to write Emacs Lisp code. PEL enhances Emacs customization system: PEL provides keys to quickly access customization groups of Emacs built-in and external Emacs Lisp libraries even if they are not even loaded.

  • The fast startup mode. It can achieve

    • sub 0.1 second startups on Linux, and
    • under 0.2 seconds on macOS, even with over 300 packages, see [6].

    In fast startup you can use all external packages you have already installed in normal startup mode but now Emacs starts much faster. You cannot use PEL customization based package installation but you can still install packages with Emacs package-list. To restore PEL's ability to control package by customization you must return to Emacs normal mode.

    PEL provides two commands to switch modes:

    • The pel-setup-fast (<f11> M-S f) activates the fast startup mode. It bundles all external packages that use a single directory inside a single directory to reduce Emacs load-path and sets up your Elpa directory for a fast startup.
    • The pel-setup-normal (<f11> M-S n) restores the normal Emacs setup with package management capabilities and PEL's automatic package installation via customization.

    Note that while PEL operating in fast startup mode installations of packages via Emacs package manager commands will be installed in the elpa-reduced directory in the standard way, not in the most efficient way. That may increase Emacs' startup time a little, but it will work.

    To maintain the highest efficiency it is best to return to normal mode when installing new packages allowing PEL to create update bundles when activating fast startup mode with all packages installed by normal mode.

    it's also best to install packages by customizing PEL user-options for the packages that PEL already supports. Please do not hesitate to request for the inclusion of new packages.

  • With PEL you can see a quick report with relevant information by executing the pel-emacs-load-stats command.

    • On a 2023 macStudio with Geekbench 6.7.1 rate of 2490 single-core/13076 multicore, with 303 elpa packages and 108 other non-elpa single file packages installed from their repos, Emacs 30.2 takes about 0.67 seconds to start in normal mode but takes just about 0.17 seconds in terminal mode and 0.23 seconds in graphics mode.

      More details:

      • 303 Elpa packages stored in: ~/.emacs.d/elpa-complete/
      • 108 Utils files stored in: ~/.emacs.d/utils/
      • size of load-path : 333 directories
      • # pel-use-... user-options : 422 (343 are active)

      In normal mode:

      GNU Emacs 30.2.50 (build 2, aarch64-apple-darwin23.6.0, NS appkit-2487.70 Version 14.8.2 (Build 23J126)) of 2025-11-26
      Emacs 30.2.50 startup time: 0.677794 seconds   (in normal mode, with package quickstart, with native compilation, in terminal mode.)
      # loaded files         : 433
      # load-path length     : 332
      # features             : 720
      # package-alist        : 303
      # packages activated   : 303
      # packages selected    : 190
      

      With PEL fast startup mode activated:

      GNU Emacs 30.2.50 (build 2, aarch64-apple-darwin23.6.0, NS appkit-2487.70 Version 14.8.2 (Build 23J126)) of 2025-11-26
      Emacs 30.2.50 startup time: 0.164187 seconds   (in fast mode, with package quickstart, with native compilation, in terminal mode.)
      # loaded files         : 421
      # load-path length     : 71
      # features             : 445
      # package-alist        : 41
      # packages activated   : 41
      # packages selected    : 190
      

  • Here's what I get on other systems with other versions of Emacs using the PEL fast startup mode:

    • On a Ubuntu 16 running inside a VM hosted by a 2014 iMac computer:

      GNU Emacs 28.2 (build 1, x86_64-pc-Linux-gnu, GTK+ Version 3.18.9, cairo version 1.14.6) of 2023-01-06
      Emacs 28.2 startup time: 0.067179 seconds   (in fast mode, without package quickstart, without native compilation, in terminal mode.)
      # loaded files         : 316
      # load-path length     : 37
      # features             : 296
      # package-alist        : 9
      # packages activated   : 9
      # packages selected    : 152
      

    • On a Rocky Linux 8 VM hosted on a 2014 iMac computer, PEL achieves this in normal mode:

      GNU Emacs 30.1.90 (build 2, x86_64-pc-Linux-gnu) of 2025-06-03
      Emacs 30.1.90 startup time: 0.313209 seconds   (in normal mode, without package quickstart, with native compilation, in terminal mode.)
      # loaded files         : 452
      # load-path length     : 131
      # features             : 432
      # package-alist        : 102
      # packages activated   : 102
      # packages selected    : 66
      

    • And this is fast startup mode:

      GNU Emacs 30.1.90 (build 2, x86_64-pc-Linux-gnu) of 2025-06-03
      Emacs 30.1.90 startup time: 0.075374 seconds   (in fast mode, without package quickstart, with native compilation, in terminal mode.)
      # loaded files         : 361
      # load-path length     : 38
      # features             : 340
      # package-alist        : 9
      # packages activated   : 9
      # packages selected    : 66
      

    • And with package quickstart and fast startup mode:

      GNU Emacs 30.1.90 (build 2, x86_64-pc-Linux-gnu) of 2025-06-03
      Emacs 30.1.90 startup time: 0.068962 seconds   (in fast mode, with package quickstart, with native compilation, in terminal mode.)
      # loaded files         : 352
      # load-path length     : 39
      # features             : 339
      # package-alist        : 9
      # packages activated   : 9
      # packages selected    : 66
      

• PEL supports Emacs 26.3 and later.

  • For Emacs 27 and later the pel-early-init-template user-option (which defaults to example/init/early-init.el) allows you to identify a PEL-compatible early-init.el file that PEL edits to control whether fast startup and package-quickstart feature are used.
    • PEL provides the pel-setup-with-quickstart command (<f11> M-S q) to create and refresh all the package-quickstart files [7] and pel-setup-no-quickstart (<f11> M-S M-q) to disable it.

• PEL uses Emacs customization facility to control everything:
  • the selection,
  • installation and
  • configuration of packages,
  • the activation of various major and minor modes,
  • the improvement of behaviour of several major and minor modes,
  • the use of the features provided by PEL.
• PEL provides a large number (422) of customizable user options to control all this and provides several commands to access the customization buffers and help commands that generate reports in *Help* like buffers listing relevant user-options and providing quick access to their customization.
• PEL saves your customization data inside a file separate from your init.el file, providing an extra degree of freedom and control. This also gives you the ability to easily revision and clone your Emacs environment to other computers.
• PEL provides enhanced and easy access to relevant customization buffers for your specific context. Each supported topic or major mode context has a PEL prefix key and each supported major mode uses the <f12> key as the main prefix key. For instance in a C buffer, use <f12> <f1> to access the C-specific PEL PDF, <f12> <f2> to access the PEL customization buffer to activate C features, and <f12> <f3> to access the customization buffers controlling the major mode and related features.
  • Unlike default Emacs behaviour, PEL can open customization buffer for a group even if it is not yet loaded. If they are not loaded PEL will load them for you after prompting. Even if the package's code was not written to support auto-loading of customization variables.
• The classical way to control Emacs behaviour has been to write Emacs Lisp code to set variables. Although you can still do it with PEL you will benefit from PEL's integration better if you control all via the customization buffers and customization files. You can modify the behaviour by applying customization modification to test your changes and then save them to a file once you are happy with it.
• PEL supports the ability to have 2 independent customization files: one for Emacs running in terminal mode and another for Emacs running in graphics mode. PEL supports two sets of elpa directories to store the packages used for each mode when this independent dual customization mode is used. PEL provides the pel-setup-dual-environment command to activate this. Follow the installation instructions and see the ⅀ Customize PDF for more details.
  • A PEL compatible Emacs init.el is available for you to use right from the beginning. Instructions are inside. You can use it as is or modify some of the options.
  • For Emacs ≥ 27, PEL also provides a PEL compatible early-init.el. Instructions are inside. PEL will automatically install it if you want to use Emacs package quickstart feature available on Emacs ≥ 27. You can also modify it and add your own code. Instructions are located in the file.
  • PEL comes with samples of Emacs custom files you can use with PEL to quickly activate features. After following the PEL installation steps, Copy one of these files into your ~/.emacs.d/emacs-customization.el file then start Emacs and watch PEL download, install and activates the packages identified in the file you selected.
  • If you want to manage 2 set of customization files and package directory, one for Emacs in terminal mode and another for Emacs in graphics mode, use the pel-setup-dual-environment command (or <f11> <f2> M-d) to activate dual independent customization. It will create the required customization files.

Emacs gets its power from the large set of built-in and external packages available for it. A large number of external packages are available from package repositories like GNU Elpa, MELPA. There are also Emacs Lisp files available on Github and Gitlab. PEL provides access to a growing number of these packages as described in the next section.

One of PEL's goals is to enhance the cohesion and the integration of the packages it supports and keep everything easily customizable.

PEL also implements template-driven text insertion for a set of programming and markup languages.

As PEL evolves the goal is to support for programming languages will increase and each fully supported programming language will come with a topic-oriented help PDF, enhanced electric key behaviours, enhanced navigation integrating packages, etc.

• In normal mode, PEL controls the download, installation, configuration and activation of 377 top-level [4] external packages through the use of easy-to-setup customization user-options that have a name that start with the "pel-use-" prefix.
  • Once activated by a PEL user option, PEL installs the newly activated packages on initialization (or when Emacs starts) from GNU Elpa, MELPA, and simple GitHub or Gitlab repositories even when the files have not been setup as an elpa-compliant package. PEL provides configuration logic and hooks where needed.
  • Use the pel-cleanup command to remove deactivated packages not requested by PEL user-options, moving those packages from the elpa or utils directory to the corresponding attic directories for backup and later re-activation.
  • PEL controls the activation and loading of selected packages, with emphasis on:
    • reducing Emacs initialization time to a minimum [6] in all modes,
    • providing key bindings when Emacs is running in both graphics mode and terminal mode,
    • adding extra commands that complement Emacs and external packages.
• PEL integrates these packages and adds a large number of key bindings. The PEL key-bindings do not interfere with the Emacs standard key bindings (except for a small number of documented ones).

• PEL provides 221 topic oriented PDF tables [5] each heavily hyperlinked to each other and to public resources. The top-level PEL Index PDF is a table listing the table for each Emacs feature, major and minor mode. Each table attempts to provide quickly accessible concise information about the features, commands, function signatures, key bindings and is packed with symbol annotated and colour coded information. It includes hyperlinks to Emacs manuals, external packages, articles and other useful references.
  • The PDF tables use colour codes and icons (see the ➢Legend PDF for their meaning) to speed identification of commands, identify if they are available globally, for major mode, minor mode or under special circumstances to help you understand Emacs.
  • Some major modes also support the opening of a language-specific PDF. This is done by using a key prefix: C-u <f12> <f1>. For example this now opens a PDF on zsh when the command is issued from a buffer editing a zsh script, or a GNU Make PDF from a buffer editing a make file in GNU Make mode.
  • Some tables describe tools like GNU make or languages, like Perl 5.

Key Strengths of PEL's PDF Documentation:

High Information Density: The index has dense, easy-to-use, visual organization. Instead of making you scroll through a 10,000-word webpage, everything—from core startup mechanics to granular language support for dozens of languages—is mapped onto a single, scannable coordinate grid.

Contextual Visual Anchors: The tables use an exact, structured color-coding framework (light-blue for major modes, light-red for minor modes, grey for cross-table anchors, and green for custom PEL extensions). This allows an advanced user to instantly identify a feature's scope just by looking at the cell background. The ➢Legend PDF explains the conventions.

Frictionless In-Editor Access: Access to PEL PDF is 2 keys away: access the index table with <f11> <f1> and the table for the major mode used in the current buffer with <f12> <f1>.

Massive Technical Breadth: The documentation charts cover everything from low-level UNIX tools (Make, CMake, Ninja) to lightweight markups, hardware description and software programming languages. Emacs is like a full operating system; PEL treats it like that.

The PEL index and all other PDFs showcase a unique approach to managing a sprawling configuration ecosystem: using heavily cross-referenced, visually dense PDF maps with hyperlinks to relevant documents.

• PEL's Manual describes PEL features in more details. See:
  • How to install PEL,
  • How to setup GUI Emacs environment to control GUI launched Emacs PATH and other environment variables easily with a fast starting Emacs,
  • PEL setup commands for dual customization and fast startup mode,
  • PEL initialization command and PEL cleanup command,
  • PEL Customization,
  • PEL Key Bindings,
  • PEL convenience features with PEL commands that extend several aspects of Emacs.

• Several Documentation Pages on various Emacs Topics, including:
  • How to build Emacs from source
  • How to recompile all Emacs Lisp files after upgrading Emacs
  • How to use Emacs stand-alone processes, daemon and clients
  • Install the Emacs launcher shortcut scripts

• PEL provides 729 extra commands or more. PEL commands extend the packages it supports and provides some of its own features. Some commands are only available for a given OS, most are accessible in every OS.

• When the pel-use-hydra user-option is turned on, PEL provides 12 specialized key Hydra and provides access to one from an external package. From the 12 Hydras, nine are PEL global hydras invoked by typing the <f7> prefix key followed by one selection key, one is an external package hydra and two are mode specific PEL hydras..

  • The global key Hydras are:

    PEL Global Hydra Name	Description	Hydra Head
    pel-∑buffer	Buffer Navigation Hydra	<f7> b
    pel-∑dumb-jump	Dumb-jump commands	<f7> j
    pel-∑greek	Greek Letters Hydra	<f7> G
    pel-∑hideshow	Hide/Show Management	<f7> H
    pel-∑say	macOS Narrator Hydra	<f7> S
    pel-∑scroll	Window scrolling	<f7> |
    pel-∑sel-display	Selective Display	<f7> M-h
    pel-∑winInfo	Window/Buffer purpose	<f7> W
    pel-∑window	Window management Hydra	<f7> w
    indent-tools-hydra	Indentation tools	<f7> <TAB>

  • PEL also provides language-specific Hydras for C and C++ major modes; both are accessed via the <f12> <f7> key sequence, a key sequence PEL uses for major-mode specific commands.

• The key bindings of several commands are the same in several major-modes but they perform actions that are specialized to the major mode of the current buffer. This helps simplify using Emacs.

• All commands, PEL commands, standard Emacs commands and the commands provided by external packages are described in the various PDF quicksheets that you can access through the PEL Topic Index PDF.

When changing Emacs from a major version to another you have to recompile all Emacs Lisp files with the version of Emacs you are now using. It is simple to do it with PEL. Read the document titled How to recompile all Emacs Lisp files after updating Emacs to a different version; it describes a simple procedure.

PEL would not exist without the great software available for Emacs. Some of them are listed in the Credits section of the manual but the list is unfortunately incomplete as it grows continuously when PEL supports new packages. The external packages are identified in the PDF tables with the box symbol: 📦 with hyper-links to the author's project.

PEL is still evolving, with new packages being integrated, new documentation created and new features developed. The evolution is described in the NEWS file.

Questions, comments, constructive criticism, suggestions and requests are always welcome. Drop me a note in the wiki or in the discussion board!