iTechGuides is reader-supported. When you buy through links on our site, we may earn an affiliate commission. As an Amazon Associate I earn from qualifying purchases. Learn more
In GNU Emacs Lisp, dynamic function loading is a byte-compilation feature that leaves some function definitions unread until the first time each function is called. A placeholder points to the compiled file; the call triggers Emacs to read that function’s full definition. It is also called lazy loading in this context.
How dynamic function loading works
The mechanism defers reading individual function bodies, not loading an entire library on demand. The compiled file is loaded first, but definitions marked for dynamic loading remain represented by placeholders. When a deferred function is first called, Emacs reads its definition from the file and replaces the placeholder.
- Compile a Lisp file with dynamic function loading enabled.
- Load the compiled file. Function definitions selected for deferral are represented by placeholders rather than fully read.
- When one of those functions is first called, Emacs reads its full definition from the compiled file.
When it can help
The GNU Emacs Lisp Reference Manual describes a potential reduction in file-loading time when a file contains many separate user-callable functions and users are likely to call only a subset. A specialized mode with many commands is one example: enabling the mode does not necessarily mean every command will be used.
This is a loading-time benefit, not evidence that a function runs faster after its definition has been read. The documentation gives no quantified performance result.
#1 Best Overall
How it differs from autoloading and shared libraries
| Mechanism | What is deferred | What triggers the load |
|---|---|---|
| Emacs Lisp dynamic function loading | An individual function definition in a compiled file that has already been loaded | The first call to that function |
| Emacs Lisp autoloading | The file containing a function’s definition | A call to the autoloaded function |
| Dynamic or shared-library loading | Code from a library at runtime | Depends on the program and operating-system mechanism; the Emacs Lisp description does not specify it |
All three defer some work, but the deferred unit differs. The Emacs Lisp feature described here defers a function within a compiled file; autoloading defers loading the defining file. The phrase should not be treated as a universal name for runtime shared-library loading.
What can go wrong with the backing file
Deferred definitions depend on the compiled file remaining available and suitable for later reads. The GNU manual warns that moving or deleting it can leave definitions that have not yet been read unavailable. Changing the file—for example, recompiling it while deferred definitions still refer to it—can cause later reads to produce incorrect results. The documented remedy after recompilation is to reload the new compiled file.
Rank #2
Version status and current guidance
A mirror reproducing GNU documentation reports that dynamic function loading has been deprecated since Emacs 27.1 and that its benefits are barely measurable in practice. Because this is version-sensitive guidance and that statement is not confirmed here against the current official GNU manual, check the manual for the Emacs version you use before relying on the feature. The description of the mechanism and its file-dependency caveats is in the GNU Emacs Lisp Reference Manual: Dynamic Loading; the deprecation report appears in a manual mirror.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
