pierre-rouleau/pel

Pragmatic Emacs Library

PEL -- Pragmatic Emacs Library

• 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 a fast single process startup even with a large number of external packages installed? 😃
• And also want to run an 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] !

➣ Supports Launching Emacs from GUI and Shell

• 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...

➣ Short Emacs and Emacs Client Launcher Scripts

• 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.

➣ Emacs Fast Startup

• Speed Emacs startup further with PEL fast startup mode command (see also ⅀ Fast Startup PDF [5]). 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 0.1 second startup with over 230 external packages, see [7]. In fast startup you can use all external packages you have already installed in normal startup mode but now Emacs starts much faster. In fast startup PEL does not support download and installation of new external packages but just return to normal mode to do so. PEL provides 2 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.
• PEL supports Emacs 26 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 [8] and pel-setup-no-quickstart (<f11> M-S M-q) to disable it.

➣ Customization Driven Package Management & Configuration

• 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 various major and minor modes,
  • the use of various features provided by PEL.
• 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 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.

➣ PEL Package Integration and Enhancements

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 these packages to provide a more pleasant and customizable user experience. PEL implements various convenience commands, easy-to-remember key bindings and glue control code to enhance several minor and major modes, allowing behaviour selection through customization and PEL use-option variables.

Some of the improvements created for PEL are fed back to the original project(s) but it's available inside PEL if the code has not yet been merged in the original project.

PEL also implements various template-driven text insertion for various 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 various packages, etc...

➣ Automatic Download, Installation and Setup of External Packages

• In normal mode, PEL controls the download, installation, configuration and activation of 250 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.
  • PEL can install packages from GNU Elpa, MELPA, and simple GitHub or Gitlab repositories even when the files have not been setup as an elpa-compliant package.
  • 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 [7] 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 that mostly do not interfere with the standard Emacs key bindings (except for a very small few documented ones).

➣ Extends Emacs Documentation

• PEL provides over 150 PDF topic-oriented reference sheets [6] packed with symbol annotated, colour coded key bindings and command descriptions, with hyperlinks to Emacs manuals, external packages, articles and other useful references.

  • See the PEL Index PDF [5] as a starting point. For the best user experience, use a browser, like Firefox, that can render the PDF inline (as opposed to downloading it) so you can use the links quickly. Inside Emacs use <f11> <f1> to open the PEL Index PDF and then navigate from it, or use <f12> <f1> to open the PDF describing the major mode of the current buffer and its key bindings.
    • 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.

• 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.

  Warning

  GitHub presently fails to render several reStructuredText files to HTML. They are currently working to resolve this issue.

➣ PEL Convenience Commands

• PEL provides over 465 extra commands. PEL commands extend the packages it supports and provides some of its own features.
• PEL provides 7 Hydra key bindings when the pel-use-hydra and the topic specific user-options are activated.

➣ Credits

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.

➣ What's New

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!

Notes

[1]

Writing Emacs Lisp code is actually quite fun and rewarding. Lisp is a powerful programming language and Emacs opens up the door to that world if it's foreign to you. PEL should ease the introduction and you may decide to go your own way later. For those that prefer to stay away from Emacs Lisp and concentrate on other tasks you can use PEL and configure Emacs using its powerful customization system.

[2]

Unfortunately PEL installation is manual but it's not difficult. Detailed instructions for installing PEL are located inside section 2 of PEL manual. You essentially have to clone PEL's repo, start with a fresh ~/.emacs.d directory, open Emacs twice and run make in the PEL directory to byte compile PEL's files. You will have to update the init.el and early-init.el if you want to modify some options. And you may want to use some canned customization files. PEL installs and configure what you activate through customization. See PEL manual table of contents to move around the manual.

[3]	The instructions for updating PEL are located inside the Updating PEL section of the PEL manual. Essentially what's required is to get the latest changes using Git (with git pull) and then run make again.

[4]

An external package may have dependencies. The dependencies are also installed. PEL currently provides access to 250 top-level external packages. The actual number of packages is larger when counting their dependencies (currently 48 extra packages installed as dependencies). From within PEL execute the pel-package-info command with prefix argument to get a full report (or just type C-u <f11> ? e ?). Also notice the short report printed at the end the make-driven build of PEL.

[5]

(1, 2) All PEL PDF files have a large number of hyperlinks to other PDF files, Emacs manual pages, external packages and articles. Use a browser that is capable of rendering PDF files for the best user experience. The Mozilla Firefox browser does an excellent job at it since its version 78, under all operating system and is highly recommended.

[6]	The source of the PEL PDF files is a single macOS Number spreadsheet file. It's also available in the Git pel-pdf-spreadsheet repo. I would have liked to find a way to create this with a markup flexible enough but I did not find one. Let me know if you know one that can build the same output.

[7]

(1, 2) Fast initialization: PEL code uses all the techniques to improve initialization speed. By default it starts quickly, delaying code as much as possible. On my 2014 iMac running macOS Mojave in terminal mode running Emacs 26.3 I get the following startup time in normal startup mode (and without package-quickstart): with 182 packages, benchmark-init reports about 0.4 second startup-time, with 239 packages, benchmark-init reports about 0.6 second startup-time, see the benchmark-init report for it Activate PEL fast startup mode to experience much faster initialization times: with 239 packages, in fast startup operation mode, benchmark-init reports about 0.1 second startup-time, see the benchmark-init report for that. The time reduction of fast startup mode depends on the number of packages that can be bundled by PEL. Those that have all their files in the same directory can be bundled. With PEL it's possible to reduce this further by removing packages you do not need, without loosing their configuration: go to normal startup mode, disable un-required packages by setting their corresponding pel-use- user-option to nil, run the pel-cleanup command (with M-x pel-cleanup). It will disable those packages by putting their packages inside an attic directory where you can retrieve them later. If the removed packages are multi-directory package their removal will speed-up initialization in normal and fast-startup mode, otherwise it will only speed it up in normal mode.

[8]

Package Quickstart Support: The pel-setup-with-quickstart command creates the package quickstart files and the early-init.el file if it's not already present. Emacs package-quickstart-file user-option identifies the name of your package quickstart file. When using PEL's independent customization for terminal/TTY and graphics Emacs PEL manages 2 package quickstart files: one for the terminal/TTY mode with that name and one for the graphics mode which has "-graphics" appended to its name.

[9]

PEL Commands: PEL implements its own commands. These complements the packages PEL supports and also provide a layer that unifies mechanisms implemented by several built-in and external packages. Some PEL commands act according to the key sequences that invoked them. For example, the pel-help-pdf command is bound to <f11> a <f1>, <f11> b <f1> and several others and the <f12> <f1> key sequences of several major modes. The command detects the key sequence and the context to identify which PEL PDF to open. PEL currently implements 541 interactive commands. Some are always loaded. Several are auto-loaded when needed. This count excludes the number of template commands that are dynamically constructed and loaded only for major modes, such as Erlang, that support extensive tempo skeleton templates. Navigate the PDF files starting from the PEL Index PDF to get more information.

pel's Issues

pel-setup-fast and pel-setup-normal fail for Emacs 27+ with package-quickstart activated.

The commands pel-setup-fast and pel-setup-normal work fine for Emacs < 27 and for Emacs >= 27 when package-quickstart is not used, but fail when package-quickstart is used.

The -autoloads.el files are not copied in the pel-bundle pseudo-package in fast startup mode

When switching to fast startup mode, the -autoloads.el files i=of single directory packages are not copied (or symlinked) into the pel-bundle pseudo package directory. This causes autoloading related issues in the related packages.

(pel-open-at-point 9) does not work under Linux Ubuntu 16

Just noticed that pel-open-at-point with 9 as a numerical argument does not launch the Linux PDF viewer on a pdf file name as it should. That works under macOS just fine though.

The command is launched from a rst-mode buffer.

Problem seen in Emacs 28.2 running in text mode

Switching from normal to fast-startup or back on Emacs 27+ with package-quickstart exhibits problems

When switching operation mode on Emacs 27 with package-quickstart activated, the switch command reports invalid directories.

I can get Emacs to work in fast-startup mode with package-quickstart active on Emacs 27+ but the commands to perform the switch fail to handle everything properly.

Refactor pel-goto-symbol command to use imenu when Ido Ubiquitous is available.

The advantage of using the imenu with Ido is that the user can select the item through the identification hierarchy. For example, for languages where classes with methods (or member functions) are identified, the user can select the name of the class first and then select the name of the method (or member function).

Ideally it should support all Ido geometries currently supported by PEL. My current favourite is Ido grid collapsed. This combination is really working well for me.

[todo]: complete support for Python

PEL fast startup fails on Emacs 27+ when package-quickstart is used

The pel-bundle is not included in the pre-build package-quickstart-file.

That can proably be fixed by adding pel-bundle specs to package-alist prior to executing `package-quickstart-refresh' at the end of pel-setup-fast.

Will fix that soon.

Add automatic installation of benchmark-init

PEL does not currently have any logic to support installation of benchmark-init.

It would be beneficial to do so because benchmark-init must be treated specially and must go into the PEL utils directory instead of the normal elpa directory.

It is better to install it inside utils because:

• installation of benchmark-init does not increase the number of directories (and the load-path) when it is installed inside utils, therefore the installation of benchmark-init does not influence Emacs startup time.
• It can then be used in both normal and fast startup modes without special file manipulation.

It should also be taken from utils (and not from utils-graphics) even in graphics mode, allowing code iniside init.el to ignore the Emacs mode.

This means that special logic will have to be used inside pel-cleanup.

Complete PEL manual documentation of imenu-based navigation.

Very first switch to fast startup fails

The very first time one performs the pel-setupfast, the symlinks inisde the pel-bundle are invalid. They point to the elpa-reduced directory, instead of the elpa-complete.

The work around is to switch back to normal mode and then to fast startup again. That fixes the symlinks.

I have a fix I will submit soon.

Enhance Speedbar based discovery of definitions

Analyze interaction of speedbar with imenu and support for various programming languages.

Excess load-path in Emacs >=27 with fast-startup, package quickstart and dual independent custom file in graphics mode

With:

• Emacs >= 27 running in Graphics mode,
• fast-startup enabled,
• package-quickstart enabled,
• independent dual customization files (terminal/graphics) enabled:

the load-path for Emacs running in graphics mode has too many entries: the elpa-reduced directories for TTY specific packages have been placed in load-path by Emacs code running between the execution of the early-init.el file and the execution of init.el file.

Following is an example of the load path. The entries 17 to 33 should have been taken from elpa-reduced-graphics directory and then not added at front into lines 1 to 14 inclusively.

The impact of this bug is a slowdown of operation caused by the excessive entries in load-path. However the packages are taken from the right place because the entries from elpa-reduce-graphics are placed at the front.

1. /Users/roup/.emacs.d/elpa-reduced-graphics/alchemist-20180312.1304
2. /Users/roup/.emacs.d/elpa-reduced-graphics/clojure-snippets-20180314.1308
3. /Users/roup/.emacs.d/elpa-reduced-graphics/auto-complete-20201213.1255
4. /Users/roup/.emacs.d/elpa-reduced-graphics/forth-mode-20210123.900
5. /Users/roup/.emacs.d/elpa-reduced-graphics/geiser-20210303.1351
6. /Users/roup/.emacs.d/elpa-reduced-graphics/lice-20200607.103
7. /Users/roup/.emacs.d/elpa-reduced-graphics/monky-20201226.1950
8. /Users/roup/.emacs.d/elpa-reduced-graphics/neotree-20200324.1946
9. /Users/roup/.emacs.d/elpa-reduced-graphics/racket-mode-20210226.1343
10. /Users/roup/.emacs.d/elpa-reduced-graphics/relint-1.19
11. /Users/roup/.emacs.d/elpa-reduced-graphics/seq-2.22
12. /Users/roup/.emacs.d/elpa-reduced-graphics/sly-20210303.1148
13. /Users/roup/.emacs.d/elpa-reduced-graphics/vterm-20210409.1558
14. /Users/roup/.emacs.d/elpa-reduced-graphics/yasnippet-snippets-20210105.1346
15. /Users/roup/dev/elisp/pel
16. /Users/roup/.emacs.d/utils
17. /Users/roup/.emacs.d/elpa-reduced/alchemist-20180312.1304
18. /Users/roup/.emacs.d/elpa-reduced/auto-complete-20201213.1255
19. /Users/roup/.emacs.d/elpa-reduced/clojure-snippets-20180314.1308
20. /Users/roup/.emacs.d/elpa-reduced/company-20210611.1224
21. /Users/roup/.emacs.d/elpa-reduced/forth-mode-20210123.900
22. /Users/roup/.emacs.d/elpa-reduced/lice-20200607.103
23. /Users/roup/.emacs.d/elpa-reduced/lsp-treemacs-20210618.1722
24. /Users/roup/.emacs.d/elpa-reduced/lsp-ui-20210604.1158
25. /Users/roup/.emacs.d/elpa-reduced/monky-20210417.12
26. /Users/roup/.emacs.d/elpa-reduced/neotree-20200324.1946
27. /Users/roup/.emacs.d/elpa-reduced/racket-mode-20210604.1431
28. /Users/roup/.emacs.d/elpa-reduced/relint-1.19
29. /Users/roup/.emacs.d/elpa-reduced/seq-2.22
30. /Users/roup/.emacs.d/elpa-reduced/sly-20210604.937
31. /Users/roup/.emacs.d/elpa-reduced/treemacs-20210606.1918
32. /Users/roup/.emacs.d/elpa-reduced/vterm-20210409.1558
33. /Users/roup/.emacs.d/elpa-reduced/yasnippet-snippets-20210408.1234
34. /Users/roup/.emacs.d/elpa-reduced-graphics/pel-bundle-20210817.2253
35. /Library/Application Support/Emacs/27.1/site-lisp
36. /Library/Application Support/Emacs/site-lisp
37. /Applications/Emacs.app/Contents/Resources/site-lisp
38. /Applications/Emacs.app/Contents/Resources/lisp
39. /Applications/Emacs.app/Contents/Resources/lisp/vc
40. /Applications/Emacs.app/Contents/Resources/lisp/url
41. /Applications/Emacs.app/Contents/Resources/lisp/textmodes
42. /Applications/Emacs.app/Contents/Resources/lisp/progmodes
43. /Applications/Emacs.app/Contents/Resources/lisp/play
44. /Applications/Emacs.app/Contents/Resources/lisp/org
45. /Applications/Emacs.app/Contents/Resources/lisp/nxml
46. /Applications/Emacs.app/Contents/Resources/lisp/net
47. /Applications/Emacs.app/Contents/Resources/lisp/mh-e
48. /Applications/Emacs.app/Contents/Resources/lisp/mail
49. /Applications/Emacs.app/Contents/Resources/lisp/leim
50. /Applications/Emacs.app/Contents/Resources/lisp/language
51. /Applications/Emacs.app/Contents/Resources/lisp/international
52. /Applications/Emacs.app/Contents/Resources/lisp/image
53. /Applications/Emacs.app/Contents/Resources/lisp/gnus
54. /Applications/Emacs.app/Contents/Resources/lisp/eshell
55. /Applications/Emacs.app/Contents/Resources/lisp/erc
56. /Applications/Emacs.app/Contents/Resources/lisp/emulation
57. /Applications/Emacs.app/Contents/Resources/lisp/emacs-lisp
58. /Applications/Emacs.app/Contents/Resources/lisp/cedet
59. /Applications/Emacs.app/Contents/Resources/lisp/calendar
60. /Applications/Emacs.app/Contents/Resources/lisp/calc
61. /Applications/Emacs.app/Contents/Resources/lisp/obsolete

Add command to parse and build and open HTML file from the reStructuredText

Investigate what is available.
Provide ability to identify a shell-based command line to perform the task via a user-option.

Emacs 27 support for fast startup broken

Activate EditorConfig only when the project (or directory tree) includes a EditorConfig configuration file.

Currently, when pel-use-editor-config is set to t, the EditorConfig library is activated. Even if there is no such need. Its wasteful and takes valuable space on the mode-line.

Reduce file system size pressure

With the support for independent terminal/TTY and graphics customization two set of directories are created for elpa and utils and files are stored in both doubling file storage size requirement.

It would help to use a directory to store the sub-directories and files and then store symlinks in the elpa and utils directories.

symlinks are already used for managing startup mode.

However, I have not yet tested all of this on Windows where symlinks may not be available. So this modification should only be done once support for Windows symlink is confirmed or implemented.

Analyze imenu source code and its capabilities

package quickstart mode with dual environment fails for graphics specific mode

The current version of PEL uses code in early-init.el to detect Emacs running in graphics mode (using an environment variable) to prepare package.el for graphic specific package-user-dir and custom-file before package.el code is run between early-init.el and init.el. This uses an :around advice. This advice makes Emacs fails.

So for the moment it's not possible to use the following combination:

• Dual environment
• Start Emacs in graphics mode with env var identifying graphic mode
• package quickstart mode activate

Seems like every other combination work.

pel-open-at-point fail extracting a file name that has parenthesis in its name.

pel-open-at-point is currently not able to open a file that has a parenthesis in its name, even though the name is valid.

Enhance reStructuredText imenu list to include section numbers in each entry

I'd like to be able to see the section numbers of a large reStructuredText document. With a format like this: 1.2.3.4.5.6.7

where:

• 1 identifies the first level (a chapter),
• 2 identifies the level 2
• 3 identifies the level 3,
• etc...

Ideally this would also show up inside the table of content generated by the rest mode.

[todo] : Add support for LSP

Add support for Emacs not launched from a shell

PEL fast-startup, terminal/graphics independent customization and package quickstart control depend on ability to detect the environment and for some of this logic that depends on Emacs being launched from a shell.

It's possible to launch Emacs from outside of a shell in several operating systems. When its done PEL code is not able to detect important information and several Emacs package are not initialized properly.

Steve Purcell provides a library to handle this but its solution increases the Emacs startup time (it launches a child shell and extracts the environment values out of that shell to add them to the ones used by future Emacs shell children).

One of PEL goals is to speed Emacs startup. Steve Purcell's library is therefore not a good fit for PEL.

On macOS it's possible to store extra environment variables inside the macOS Emacs app bundle Info.plist file. This however is not very flexible and also only works on macOS.

Compounding the problem is the fact that some decisions PEL must make have to be taken inside the execution of early-init.el which is before the customization file is loaded. For the moment only one environment-based decision must be taken by PEL inside early-init.el: to determine if Emacs is running in terminal or graphics mode.

• The proposed solution to this problem is to set the PEL_RUNNING_IN_GRAPHICS environment variable to indicate that Emacs is running in graphics mode. That's possible to do when the graphical instance of Emacs is launched from a shell. But if it's launched from a GUI application like Windows Explorer or macOS Finder, then other ways must be used.
  ** on macOS the value can be set inside the Info.plist file of the app bundle.
  ** on Windows: I'm not sure it can be done.
  ** on Linux, and other Unix OS graphical environments: also not sure if that can be done.

One possible solution would be to find a environment variable that is always defined when Emacs was launched from a shell and that is also not defined when Emacs is launched from a GUI program like Windows Explorer or macOS Finder.

• on macOS running Bash, the _ environment variable can be used for that. It is only set when Emacs was launched from Bash.
• It would be possible to use a different overall strategy that would work everywhere and does not require special technology: use several environment variables:
  ** one environment variable to identify that a shell was a Emacs parent, something like: PEL_SHELL. This could also identify the shell type.
  *** If PEL_SHELL is not set we know Emacs is running in graphics mode.
  *** If PEL_SHELL is set we know Emacs was launched from a shell, we then use a second environment variable to distinguish terminal and graphics mode: PEL_RUNNING_IN_GRAPHICS is set when graphics EMACS is launched.

CURRENT PROPOSED SOLUTION:

• Define the PEL_SHELL environment variable inside the shell, for instance inside the ~/.bash_profile when Bash is used. That is used to identify the presence of a shell. PEL code would be modified to expect that environment variable.
  ** If PEL_SHELL environment variable is not present, PEL provides customization user-option variable to add or append values to the Emacs environment: pel-gui-process-environment, a list of key-value pairs where the key is the environment variable name and the value is the string to set or append to a possibly existing environment variable.
  *** PEL would provide logic to inject the extra values defined by pel-gui-process-environment into the environment (via functionsetenv or variables exec-path and eshell-path-env) when PEL_SHELL is not set.

Regression supporting independent customization for graphics and terminal mode introduced with support for fast-start

Support for fast-start mode involves handling different copies of the elpa directory inside the user-emacs-directory and using symlinks.

When PEL is configured to support independent customization file for Emacs running in graphics mode versus running in terminal (TTY) mode, it also uses a different elpa directory (elpa-graphics). Logic is missing to handle the switching when init.el sets pel-use-graphic-specific-custom-file-p non-nil and PEL ends up downloading and re-building some of the external package a multiple time.

I have not yet fully qualified the problem.

Investigate Ivy to see if it is possible to get the following Ido features when using Ivy: directory merging and toggling of ignored files.

I find the following Ido features really useful:

• Ido "directory merging". With it you can type the (potentially partial) name of a file that resides in a different directory (that was previously visited) and Ido will, after a small configurable delay, change the path to match. I have not yet seen this capability inside Ivy.
• Ido has the ability to identify files that are "not important" and can hide or show them in a prompt. "Non important" files are output files (like object files, byte-compile files), etc.. So far with Ivy I have only been able to use patters to filter out these files. Something that is not required when using Ido.

Enhance Navigation based on imenu discovered definitions

Complete analysis of:

• imenu code itself
• imenu+

Test it on several programming languages, including: C, C++, D, Go, Rust, Python, Erlang, Elixir

Analyze interaction with input completion:

• Can we turn the imenu command into a powerful goto definition with good completion? Replacing what I have assigned to M-g M-h?

pel-open-at-point 29 in dired buffer does not open the directory in OS application

When passing 29 numeric argument to pel-open-at-point pointing to a file inside a dired buffer, the function should launch the OS-specific application to browse the directory. But it does not work; nothing happens.