Skip to content

Main Navigation

Home
(emacs)
- *Info*
  (intro)
  (manual)
- *Help*
  (describe-function)
  (describe-variable)
  (describe-face)

Appearance

Sidebar Navigation

Top

Introduction

Caveats
Lisp History
Conventions
- Some Terms
  nil and t
  Evaluation Notation
  Printing Notation
  Error Messages
  Buffer Text Notation
  Format of Descriptions
  - A Sample Function Description
    A Sample Variable Description
Version Information
Acknowledgments

Lisp Data Types

Printed Representation and Read Syntax
Special Read Syntax
Comments
Programming Types
- Integer Type
  Floating-Point Type
  Character Type
  - Basic Char Syntax
    General Escape Syntax
    Control-Character Syntax
    Meta-Character Syntax
    Other Character Modifier Bits
  Symbol Type
  Sequence Types
  Cons Cell and List Types
  - Drawing Lists as Box Diagrams
    Dotted Pair Notation
    Association List Type
  Array Type
  String Type
  - Syntax for Strings
    Non-ASCII Characters in Strings
    Nonprinting Characters in Strings
    Text Properties in Strings
  Vector Type
  Char-Table Type
  Bool-Vector Type
  Hash Table Type
  Function Type
  Macro Type
  Primitive Function Type
  Closure Function Type
  Record Type
  Type Descriptors
  Type Specifiers
  Autoload Type
  Finalizer Type
Editing Types
- Buffer Type
  Marker Type
  Window Type
  Frame Type
  Terminal Type
  Window Configuration Type
  Frame Configuration Type
  Process Type
  Thread Type
  Mutex Type
  Condition Variable Type
  Stream Type
  Keymap Type
  Overlay Type
  Font Type
  Xwidget Type
Read Syntax for Circular Objects
Type Predicates
Equality Predicates
Mutability
Type Hierarchy of Emacs Lisp Objects

Numbers

Integer Basics
Floating-Point Basics
Type Predicates for Numbers
Comparison of Numbers
Numeric Conversions
Arithmetic Operations
Rounding Operations
Bitwise Operations on Integers
Standard Mathematical Functions
Random Numbers

Strings and Characters

String and Character Basics
Predicates for Strings
Creating Strings
Modifying Strings
Comparison of Characters and Strings
Conversion of Characters and Strings
Formatting Strings
Custom Format Strings
Case Conversion in Lisp
The Case Table

Lists

Lists and Cons Cells
Predicates on Lists
Accessing Elements of Lists
Building Cons Cells and Lists
Modifying List Variables
Modifying Existing List Structure
- Altering List Elements with setcar
  Altering the CDR of a List
  Functions that Rearrange Lists
Using Lists as Sets
Association Lists
Property Lists
- Property Lists and Association Lists
  Property Lists Outside Symbols

Sequences, Arrays, and Vectors

Sequences
Arrays
Functions that Operate on Arrays
Vectors
Functions for Vectors
Char-Tables
Bool-vectors
Managing a Fixed-Size Ring of Objects

Records

Record Functions
Backward Compatibility

Hash Tables

Creating Hash Tables
Hash Table Access
Defining Hash Comparisons
Other Hash Table Functions

Symbols

Symbol Components
Defining Symbols
Creating and Interning Symbols
Symbol Properties
- Accessing Symbol Properties
  Standard Symbol Properties
Shorthands
- Exceptions
Symbols with Position

Evaluation

Introduction to Evaluation
Kinds of Forms
- Self-Evaluating Forms
  Symbol Forms
  Classification of List Forms
  Symbol Function Indirection
  Evaluation of Function Forms
  Lisp Macro Evaluation
  Special Forms
  Autoloading
Quoting
Backquote
Eval
Deferred and Lazy Evaluation

Control Structures

Sequencing
Conditionals
Constructs for Combining Conditions
Pattern-Matching Conditional
- The pcase macro
  Extending pcase
  Backquote-Style Patterns
  Destructuring with pcase Patterns
  The cond* macro
Iteration
Generators
Nonlocal Exits
- Explicit Nonlocal Exits: catch and throw
  Examples of catch and throw
  Errors
  - How to Signal an Error
    How Emacs Processes Errors
    Writing Code to Handle Errors
    Error Symbols and Condition Names
  Cleaning Up from Nonlocal Exits
Conditional Compilation

Variables

Global Variables
Variables that Never Change
Local Variables
When a Variable is Void
Defining Global Variables
Tips for Defining Variables Robustly
Accessing Variable Values
Setting Variable Values
Running a function when a variable is changed.
- Limitations
Scoping Rules for Variable Bindings
- Lexical Binding
  Dynamic Binding
  Proper Use of Dynamic Binding
  Selecting Lisp Dialect
  Converting to Lexical Binding
Buffer-Local Variables
- Introduction to Buffer-Local Variables
  Creating and Deleting Buffer-Local Bindings
  The Default Value of a Buffer-Local Variable
File Local Variables
Directory Local Variables
Connection Local Variables
- Connection Local Profiles
  Applying Connection Local Variables
Variable Aliases
Variables with Restricted Values
Generalized Variables
- The setf Macro
  Defining new setf forms
Multisession Variables

Functions

What Is a Function?
Lambda Expressions
- Components of a Lambda Expression
  A Simple Lambda Expression Example
  Features of Argument Lists
  Documentation Strings of Functions
Naming a Function
Defining Functions
- Finding Definitions
Calling Functions
Mapping Functions
Anonymous Functions
Generic Functions
Accessing Function Cell Contents
Closures
Open Closures
Advising Emacs Lisp Functions
- Primitives to manipulate advices
  Advising Named Functions
  Ways to compose advice
  Adapting code using the old defadvice
  Advice and Byte Code
Declaring Functions Obsolete
Inline Functions
The declare Form
Telling the Compiler that a Function is Defined
Determining whether a Function is Safe to Call
Other Topics Related to Functions

Macros

A Simple Example of a Macro
Expansion of a Macro Call
Macros and Byte Compilation
Defining Macros
Common Problems Using Macros
- Wrong Time
  Evaluating Macro Arguments Repeatedly
  Local Variables in Macro Expansions
  Evaluating Macro Arguments in Expansion
  How Many Times is the Macro Expanded?
Indenting Macros

Customization Settings

Common Item Keywords
Defining Customization Groups
Defining Customization Variables
Customization Types
- Simple Types
  Composite Types
  Splicing into Lists
  Type Keywords
  Defining New Types
Applying Customizations
Custom Themes

Loading

How Programs Do Loading
Load Suffixes
Library Search
Loading Non-ASCII Characters
Autoload
- Autoload by Prefix
  When to Use Autoload
Repeated Loading
Features
Which File Defined a Certain Symbol
Unloading
Hooks for Loading
Emacs Dynamic Modules

Byte Compilation

Performance of Byte-Compiled Code
Byte-Compilation Functions
Documentation Strings and Compilation
Evaluation During Compilation
Compiler Errors
Closure Function Objects
Disassembled Byte-Code

Compilation of Lisp to Native Code

Native-Compilation Functions
Native-Compilation Variables

Debugging Lisp Programs

The Lisp Debugger
- Entering the Debugger on an Error
  Debugging Redisplay Errors
  Debugging Infinite Loops
  Entering the Debugger on a Function Call
  Entering the debugger when a variable is modified
  Explicit Entry to the Debugger
  Using the Debugger
  Backtraces
  Debugger Commands
  Invoking the Debugger
  Internals of the Debugger
Edebug
- Using Edebug
  Instrumenting for Edebug
  Edebug Execution Modes
  Jumping
  Miscellaneous Edebug Commands
  Breaks
  - Edebug Breakpoints
    Global Break Condition
    Source Breakpoints
  Trapping Errors
  Edebug Views
  Evaluation
  Evaluation List Buffer
  Printing in Edebug
  Trace Buffer
  Coverage Testing
  The Outside Context
  - Checking Whether to Stop
    Edebug Display Update
    Edebug Recursive Edit
  Edebug and Macros
  - Instrumenting Macro Calls
    Specification List
    Backtracking in Specifications
    Specification Examples
  Edebug Options
Debugging Invalid Lisp Syntax
- Excess Open Parentheses
  Excess Close Parentheses
Test Coverage
Profiling

Reading and Printing Lisp Objects

Introduction to Reading and Printing
Input Streams
Input Functions
Output Streams
Output Functions
Variables Affecting Output
Overriding Output Variables

Minibuffers

Introduction to Minibuffers
Reading Text Strings with the Minibuffer
Reading Lisp Objects with the Minibuffer
Minibuffer History
Initial Input
Completion
- Basic Completion Functions
  Completion and the Minibuffer
  Minibuffer Commands that Do Completion
  High-Level Completion Functions
  Reading File Names
  Completion Variables
  Programmed Completion
  Completion in Ordinary Buffers
Yes-or-No Queries
Asking Multiple-Choice Questions
Reading a Password
Minibuffer Commands
Minibuffer Windows
Minibuffer Contents
Recursive Minibuffers
Inhibiting Interaction
Minibuffer Miscellany

Command Loop

Command Loop Overview
Defining Commands
- Using interactive
  Code Characters for interactive
  Examples of Using interactive
  Specifying Modes For Commands
  Select among Command Alternatives
Interactive Call
Distinguish Interactive Calls
Information from the Command Loop
Adjusting Point After Commands
Input Events
- Keyboard Events
  Function Keys
  Mouse Events
  Click Events
  Drag Events
  Button-Down Events
  Repeat Events
  Motion Events
  Touchscreen Events
  Focus Events
  Xwidget events
  Miscellaneous System Events
  Event Examples
  Classifying Events
  Accessing Mouse Events
  Accessing Scroll Bar Events
  Putting Keyboard Events in Strings
Reading Input
- Key Sequence Input
  Reading One Event
  Modifying and Translating Input Events
  Invoking the Input Method
  Quoted Character Input
  Miscellaneous Event Input Features
Special Events
Waiting for Elapsed Time or Input
Quitting
Prefix Command Arguments
Recursive Editing
Disabling Commands
Command History
Keyboard Macros

Keymaps

Keymap Basics
Changing Key Bindings
Format of Keymaps
Creating Keymaps
Inheritance and Keymaps
Prefix Keys
Active Keymaps
Searching the Active Keymaps
Controlling the Active Keymaps
Key Lookup
Functions for Key Lookup
Key Sequences
Low-Level Key Binding
Remapping Commands
Keymaps for Translating Sequences of Events
- Interaction with normal keymaps
Commands for Binding Keys
Scanning Keymaps
Menu Keymaps
- Defining Menus
  - Simple Menu Items
    Extended Menu Items
    Menu Separators
    Alias Menu Items
  Menus and the Mouse
  Menus and the Keyboard
  Menu Example
  The Menu Bar
  Tool bars
  Modifying Menus
  Easy Menu

Major and Minor Modes

Hooks
- Running Hooks
  Setting Hooks
Major Modes
- Major Mode Conventions
  How Emacs Chooses a Major Mode
  Getting Help about a Major Mode
  Defining Derived Modes
  Basic Major Modes
  Mode Hooks
  Tabulated List mode
  Generic Modes
  Major Mode Examples
Minor Modes
- Conventions for Writing Minor Modes
  Keymaps and Minor Modes
  Defining Minor Modes
Mode Line Format
- Mode Line Basics
  The Data Structure of the Mode Line
  The Top Level of Mode Line Control
  Variables Used in the Mode Line
  %-Constructs in the Mode Line
  Properties in the Mode Line
  Window Header Lines
  Window Tab Lines
  Emulating Mode Line Formatting
Imenu
Outline Minor Mode
Font Lock Mode
- Font Lock Basics
  Search-based Fontification
  Customizing Search-Based Fontification
  Other Font Lock Variables
  Levels of Font Lock
  Precalculated Fontification
  Faces for Font Lock
  Syntactic Font Lock
  Multiline Font Lock Constructs
  - Font Lock Multiline
    Region to Fontify after a Buffer Change
  Parser-based Font Lock
Automatic Indentation of code
- Simple Minded Indentation Engine
  - SMIE Setup and Features
    Operator Precedence Grammars
    Defining the Grammar of a Language
    Defining Tokens
    Living With a Weak Parser
    Specifying Indentation Rules
    Helper Functions for Indentation Rules
    Sample Indentation Rules
    Customizing Indentation
  Parser-based Indentation
Desktop Save Mode

Documentation

Documentation Basics
Access to Documentation Strings
Substituting Key Bindings in Documentation
Text Quoting Style
Describing Characters for Help Messages
Help Functions
Documentation Groups

Files

Visiting Files
- Functions for Visiting Files
  Subroutines of Visiting
Saving Buffers
Reading from Files
Writing to Files
File Locks
Information about Files
- Testing Accessibility
  Distinguishing Kinds of Files
  Truenames
  File Attributes
  Extended File Attributes
  Locating Files in Standard Places
Changing File Names and Attributes
Files and Secondary Storage
File Names
- File Name Components
  Absolute and Relative File Names
  Directory Names
  Functions that Expand Filenames
  Generating Unique File Names
  File Name Completion
  Standard File Names
Contents of Directories
Creating, Copying and Deleting Directories
Making Certain File Names “Magic”
File Format Conversion
- Overview
  Round-Trip Specification
  Piecemeal Specification

Backups and Auto-Saving

Backup Files
- Making Backup Files
  Backup by Renaming or by Copying?
  Making and Deleting Numbered Backup Files
  Naming Backup Files
Auto-Saving
Reverting

Buffers

Buffer Basics
The Current Buffer
Buffer Names
Buffer File Name
Buffer Modification
Buffer Modification Time
Read-Only Buffers
The Buffer List
Creating Buffers
Killing Buffers
Indirect Buffers
Swapping Text Between Two Buffers
The Buffer Gap

Windows

Basic Concepts of Emacs Windows
Windows and Frames
Selecting Windows
Window Sizes
Resizing Windows
Preserving Window Sizes
Splitting Windows
Deleting Windows
Recombining Windows
Resurrecting Windows
Changing Window Layouts
Cyclic Ordering of Windows
Buffers and Windows
Switching to a Buffer in a Window
Displaying a Buffer in a Suitable Window
- Choosing a Window for Displaying a Buffer
  Action Functions for Buffer Display
  Action Alists for Buffer Display
  Additional Options for Displaying Buffers
  Precedence of Action Functions
  The Zen of Buffer Display
Window History
Dedicated Windows
Quitting Windows
Side Windows
- Displaying Buffers in Side Windows
  Side Window Options and Functions
  Frame Layouts with Side Windows
Atomic Windows
Windows and Point
The Window Start and End Positions
Textual Scrolling
Vertical Fractional Scrolling
Horizontal Scrolling
Coordinates and Windows
Mouse Window Auto-selection
Window Configurations
Window Parameters
Hooks for Window Scrolling and Changes

Frames

Creating Frames
Multiple Terminals
Frame Geometry
- Frame Layout
  Frame Font
  Frame Position
  Frame Size
  Implied Frame Resizing
Frame Parameters
- Access to Frame Parameters
  Initial Frame Parameters
  Window Frame Parameters
  - Basic Parameters
    Position Parameters
    Size Parameters
    Layout Parameters
    Buffer Parameters
    Frame Interaction Parameters
    Mouse Dragging Parameters
    Window Management Parameters
    Cursor Parameters
    Font and Color Parameters
  Geometry
Terminal Parameters
Frame Titles
Deleting Frames
Finding All Frames
Splitting and Merging Frames
Minibuffers and Frames
Input Focus
Visibility of Frames
Raising, Lowering and Restacking Frames
Frame Configurations
Child Frames
- Child Frame Operations
  Child Frame Properties
  Child Frame Peculiarities
Mouse Tracking
Mouse Position
Pop-Up Menus
On-Screen Keyboards
Dialog Boxes
Pointer Shape
Window System Selections
Accessing Selections
- X Selections
  Other Selections
Yanking Media
Drag and Drop
Color Names
Text Terminal Colors
X Resources
Display Feature Testing

Positions

Point
Motion
- Motion by Characters
  Motion by Words
  Motion to an End of the Buffer
  Motion by Text Lines
  Motion by Screen Lines
  Moving over Balanced Expressions
  Skipping Characters
Excursions
Narrowing

Markers

Overview of Markers
Predicates on Markers
Functions that Create Markers
Information from Markers
Marker Insertion Types
Moving Marker Positions
The Mark
The Region

Text

Examining Text Near Point
Examining Buffer Contents
Comparing Text
Inserting Text
User-Level Insertion Commands
Deleting Text
User-Level Deletion Commands
The Kill Ring
- Kill Ring Concepts
  Functions for Killing
  Yanking
  Functions for Yanking
  Low-Level Kill Ring
  Internals of the Kill Ring
Undo
Maintaining Undo Lists
Filling
Margins for Filling
Adaptive Fill Mode
Auto Filling
Sorting Text
Counting Columns
Indentation
- Indentation Primitives
  Indentation Controlled by Major Mode
  Indenting an Entire Region
  Indentation Relative to Previous Lines
  Adjustable Tab Stops
  Indentation-Based Motion Commands
Case Changes
Text Properties
- Examining Text Properties
  Changing Text Properties
  Text Property Search Functions
  Properties with Special Meanings
  Formatted Text Properties
  Stickiness of Text Properties
  Lazy Computation of Text Properties
  Defining Clickable Text
  Defining and Using Fields
  Why Text Properties are not Intervals
Substituting for a Character Code
Registers
Transposition of Text
Replacing Buffer Text
Dealing With Compressed Data
Base 64 Encoding
Checksum/Hash
Suspicious Text
GnuTLS Cryptography
- Format of GnuTLS Cryptography Inputs
  GnuTLS Cryptographic Functions
Database
Parsing HTML and XML
- Document Object Model
Parsing and generating JSON values
JSONRPC communication
- Overview
  Process-based JSONRPC connections
  JSONRPC JSON object format
  Deferred JSONRPC requests
Atomic Change Groups
Change Hooks
- Keeping track of buffer modifications

Non-ASCII Characters

Text Representations
Disabling Multibyte Characters
Converting Text Representations
Selecting a Representation
Character Codes
Character Properties
Character Sets
Scanning for Character Sets
Translation of Characters
Coding Systems
- Basic Concepts of Coding Systems
  Encoding and I/O
  Coding Systems in Lisp
  User-Chosen Coding Systems
  Default Coding Systems
  Specifying a Coding System for One Operation
  Explicit Encoding and Decoding
  Terminal I/O Encoding
Input Methods
Locales

Searching and Matching

Searching for Strings
Searching and Case
Regular Expressions
- Syntax of Regular Expressions
  - Special Characters in Regular Expressions
    Character Classes
    Backslash Constructs in Regular Expressions
  Complex Regexp Example
  The rx Structured Regexp Notation
  - Constructs in rx regexps
    Functions and macros using rx regexps
    Defining new rx forms
  Regular Expression Functions
  Problems with Regular Expressions
Regular Expression Searching
Longest-match searching for regular expression matches
The Match Data
- Replacing the Text that Matched
  Simple Match Data Access
  Accessing the Entire Match Data
  Saving and Restoring the Match Data
Search and Replace
Standard Regular Expressions Used in Editing
Emacs versus POSIX Regular Expressions

Syntax Tables

Syntax Table Concepts
Syntax Descriptors
- Table of Syntax Classes
  Syntax Flags
Syntax Table Functions
Syntax Properties
Motion and Syntax
Parsing Expressions
- Motion Commands Based on Parsing
  Finding the Parse State for a Position
  Parser State
  Low-Level Parsing
  Parameters to Control Parsing
Syntax Table Internals
Categories

Parsing Expression Grammars

PEX Definitions
Parsing Actions
Writing PEG Rules

Parsing Program Source

Tree-sitter Language Grammar
Using Tree-sitter Parser
Retrieving Nodes
Accessing Node Information
Pattern Matching Tree-sitter Nodes
User-defined “Things” and Navigation
Parsing Text in Multiple Languages
Developing major modes with tree-sitter
Tree-sitter C API Correspondence

Abbrevs and Abbrev Expansion

Abbrev Tables
Defining Abbrevs
Saving Abbrevs in Files
Looking Up and Expanding Abbreviations
Standard Abbrev Tables
Abbrev Properties
Abbrev Table Properties

Threads

Basic Thread Functions
Mutexes
Condition Variables
The Thread List

Processes

Functions that Create Subprocesses
Shell Arguments
Creating a Synchronous Process
Creating an Asynchronous Process
Deleting Processes
Process Information
Sending Input to Processes
Sending Signals to Processes
Receiving Output from Processes
- Process Buffers
  Process Filter Functions
  Decoding Process Output
  Accepting Output from Processes
  Processes and Threads
Sentinels: Detecting Process Status Changes
Querying Before Exit
Accessing Other Processes
Transaction Queues
Network Connections
Network Servers
Datagrams
Low-Level Network Access
- make-network-process
  Network Options
  Testing Availability of Network Features
Misc Network Facilities
Communicating with Serial Ports
Packing and Unpacking Byte Arrays
- Describing Data Layout
  Functions to Unpack and Pack Bytes
  Advanced data layout specifications

Emacs Display

Refreshing the Screen
Forcing Redisplay
Truncation
The Echo Area
- Displaying Messages in the Echo Area
  Reporting Operation Progress
  Logging Messages in *Messages*
  Echo Area Customization
Reporting Warnings
- Warning Basics
  Warning Variables
  Warning Options
  Delayed Warnings
Invisible Text
Selective Display
Temporary Displays
Overlays
- Managing Overlays
  Overlay Properties
  Searching for Overlays
Size of Displayed Text
Line Height
Faces
- Face Attributes
  Defining Faces
  Face Attribute Functions
  Displaying Faces
  Face Remapping
  Functions for Working with Faces
  Automatic Face Assignment
  Basic Faces
  Font Selection
  Looking Up Fonts
  Fontsets
  Low-Level Font Representation
Fringes
- Fringe Size and Position
  Fringe Indicators
  Fringe Cursors
  Fringe Bitmaps
  Customizing Fringe Bitmaps
  The Overlay Arrow
Scroll Bars
Window Dividers
The display Property
- Display Specs That Replace The Text
  Specified Spaces
  Pixel Specification for Spaces
  Other Display Specifications
  Displaying in the Margins
Images
- Image Formats
  Image Descriptors
  XBM Images
  XPM Images
  ImageMagick Images
  SVG Images
  Other Image Types
  Defining Images
  Showing Images
  Multi-Frame Images
  Image Cache
Icons
Embedded Native Widgets
Buttons
- Button Properties
  Button Types
  Making Buttons
  Manipulating Buttons
  Button Buffer Commands
Abstract Display
- Abstract Display Functions
  Abstract Display Example
Blinking Parentheses
Character Display
- Usual Display Conventions
  Display Tables
  Active Display Table
  Glyphs
  Glyphless Character Display
Beeping
Window Systems
Tooltips
Bidirectional Display

Operating System Interface

Starting Up Emacs
- Summary: Sequence of Actions at Startup
  The Init File
  Terminal-Specific Initialization
  Command-Line Arguments
Getting Out of Emacs
- Killing Emacs
  Suspending Emacs
Operating System Environment
User Identification
Time of Day
Time Zone Rules
Time Conversion
Parsing and Formatting Times
Processor Run time
Time Calculations
Timers for Delayed Execution
Idle Timers
Terminal Input
- Input Modes
  Recording Input
Terminal Output
Sound Output
Operating on X11 Keysyms
Batch Mode
Session Management
Desktop Notifications
Controlling System GUI Taskbar Features
Block System Sleep and Process Sleep Events
Notifications on File Changes
Dynamically Loaded Libraries
Security Considerations

Preparing Lisp code for distribution

Packaging Basics
Simple Packages
Multi-file Packages
Creating and Maintaining Package Archives
Interfacing to an archive web server
Supporting older versions of Emacs
Get built-in packages and versions

Emacs 30 Antinews

GNU Free Documentation License

GNU General Public License

Tips and Conventions

Emacs Lisp Coding Conventions
Key Binding Conventions
Emacs Programming Tips
Tips for Making Compiled Code Fast
Tips for Avoiding Compiler Warnings
Tips for Documentation Strings
Tips for Documentation Groups
Tips on Writing Comments
Conventional Headers for Emacs Libraries

GNU Emacs Internals

Building Emacs
Garbage Collection
Stack-allocated Objects
Memory Usage
C Dialect
Writing Emacs Primitives
Writing Dynamically-Loaded Modules
- Module Initialization Code
  Writing Module Functions
  Conversion Between Lisp and Module Values
  Miscellaneous Convenience Functions for Modules
  Nonlocal Exits in Modules
Object Internals
- Buffer Internals
  Window Internals
  Process Internals
C Integer Types

Standard Errors

Standard Keymaps

Standard Hooks

Index

On this page

Reporting Warnings

Warnings are a facility for a program to inform the user of a possible problem, but continue running (as opposed to signaling an error, see Errors).

Warning Basics
Warning Variables
Warning Options
Delayed Warnings

Pager

Previous pageEcho Area Customization
Controlling the echo area.

Next pageWarning Basics
Warnings concepts and functions to report them.

Docs

Emacs
Elisp
Gallery
Elisp Docs

Sites

GNU
Org Mode
FSF

More

Other Manuals
Q & A
License(s)
Codeberg