Skip to main content

Emacs Lisp

The homepage for GNU Emacs is at For information on using Emacs, refer to the Emacs Manual. To view this manual in other formats, click here.

This is the GNU Emacs Lisp Reference Manual corresponding to Emacs version 27.2.

Copyright © 1990–1996, 1998–2021 Free Software Foundation, Inc.

Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with the Invariant Sections being “GNU General Public License," with the Front-Cover Texts being “A GNU Manual," and with the Back-Cover Texts as in (a) below. A copy of the license is included in the section entitled “GNU Free Documentation License."

(a) The FSF’s Back-Cover Text is: “You have the freedom to copy and modify this GNU manual. Buying copies from the FSF supports it in developing GNU and promoting software freedom."

IntroductionIntroduction and conventions used.
Lisp Data TypesData types of objects in Emacs Lisp.
NumbersNumbers and arithmetic functions.
Strings and CharactersStrings, and functions that work on them.
ListsLists, cons cells, and related functions.
Sequences Arrays VectorsLists, strings and vectors are called sequences. Certain functions act on any kind of sequence. The description of vectors is here as well.
RecordsCompound objects with programmer-defined types.
Hash TablesVery fast lookup-tables.
SymbolsSymbols represent names, uniquely.
EvaluationHow Lisp expressions are evaluated.
Control StructuresConditionals, loops, nonlocal exits.
VariablesUsing symbols in programs to stand for values.
FunctionsA function is a Lisp program that can be invoked from other functions.
MacrosMacros are a way to extend the Lisp language.
CustomizationMaking variables and faces customizable.
LoadingReading files of Lisp code into Lisp.
Byte CompilationCompilation makes programs run faster.
DebuggingTools and tips for debugging Lisp programs.
Read and PrintConverting Lisp objects to text and back.
MinibuffersUsing the minibuffer to read input.
Command LoopHow the editor command loop works, and how you can call its subroutines.
KeymapsDefining the bindings from keys to commands.
ModesDefining major and minor modes.
DocumentationWriting and using documentation strings.
FilesAccessing files.
Backups and Auto-SavingControlling how backups and auto-save files are made.
BuffersCreating and using buffer objects.
WindowsManipulating windows and displaying buffers.
FramesMaking multiple system-level windows.
PositionsBuffer positions and motion functions.
MarkersMarkers represent positions and update automatically when the text is changed.
TextExamining and changing text in buffers.
Non-ASCII CharactersNon-ASCII text in buffers and strings.
Searching and MatchingSearching buffers for strings or regexps.
Syntax TablesThe syntax table controls word and list parsing.
AbbrevsHow Abbrev mode works, and its data structures.
ThreadsConcurrency in Emacs Lisp.
ProcessesRunning and communicating with subprocesses.
DisplayFeatures for controlling the screen display.
System InterfaceGetting the user id, system type, environment variables, and other such things.
PackagingPreparing Lisp code for distribution.
AntinewsInfo for users downgrading to Emacs 26.
GNU Free Documentation LicenseThe license for this documentation.
GPLConditions for copying and changing GNU Emacs.
TipsAdvice and coding conventions for Emacs Lisp.
GNU Emacs InternalsBuilding and dumping Emacs; internal data structures.
Standard ErrorsList of some standard error symbols.
Standard KeymapsList of some standard keymaps.
Standard HooksList of some standard hook variables.
IndexIndex including concepts, functions, variables, and other terms.

Detailed Node Listing​

Here are other nodes that are subnodes of those already listed, mentioned here so you can get to them in one step:

CaveatsFlaws and a request for help.
Lisp HistoryEmacs Lisp is descended from Maclisp.
ConventionsHow the manual is formatted.
Version InfoWhich Emacs version is running?
AcknowledgmentsThe authors, editors, and sponsors of this manual.
Some TermsExplanation of terms we use in this manual.
nil and tHow the symbols nil and t are used.
Evaluation NotationThe format we use for examples of evaluation.
Printing NotationThe format we use when examples print text.
Error MessagesThe format we use for examples of errors.
Buffer Text NotationThe format we use for buffer contents in examples.
Format of DescriptionsNotation for describing functions, variables, etc.
Format of Descriptions
A Sample Function DescriptionA description of an imaginary function, foo.
A Sample Variable DescriptionA description of an imaginary variable, electric-future-map.
Lisp Data Types
Printed RepresentationHow Lisp objects are represented as text.
Special Read SyntaxAn overview of all the special sequences.
CommentsComments and their formatting conventions.
Programming TypesTypes found in all Lisp systems.
Editing TypesTypes specific to Emacs.
Circular ObjectsRead syntax for circular structure.
Type PredicatesTests related to types.
Equality PredicatesTests of equality between any two objects.
MutabilitySome objects should not be modified.
Programming Types
Integer TypeNumbers without fractional parts.
Floating-Point TypeNumbers with fractional parts and with a large range.
Character TypeThe representation of letters, numbers and control characters.
Symbol TypeA multi-use object that refers to a function, variable, or property list, and has a unique identity.
Sequence TypeBoth lists and arrays are classified as sequences.
Cons Cell TypeCons cells, and lists (which are made from cons cells).
Array TypeArrays include strings and vectors.
String TypeAn (efficient) array of characters.
Vector TypeOne-dimensional arrays.
Char-Table TypeOne-dimensional sparse arrays indexed by characters.
Bool-Vector TypeOne-dimensional arrays of t or nil.
Hash Table TypeSuper-fast lookup tables.
Function TypeA piece of executable code you can call from elsewhere.
Macro TypeA method of expanding an expression into another expression, more fundamental but less pretty.
Primitive Function TypeA function written in C, callable from Lisp.
Byte-Code TypeA function written in Lisp, then compiled.
Record TypeCompound objects with programmer-defined types.
Type DescriptorsObjects holding information about types.
Autoload TypeA type used for automatically loading seldom-used functions.
Finalizer TypeRuns code when no longer reachable.
Character Type
Basic Char SyntaxSyntax for regular characters.
General Escape SyntaxHow to specify characters by their codes.
Ctl-Char SyntaxSyntax for control characters.
Meta-Char SyntaxSyntax for meta-characters.
Other Char BitsSyntax for hyper-, super-, and alt-characters.
Cons Cell and List Types
Box DiagramsDrawing pictures of lists.
Dotted Pair NotationA general syntax for cons cells.
Association List TypeA specially constructed list.
String Type
Syntax for StringsHow to specify Lisp strings.
Non-ASCII in StringsInternational characters in strings.
Nonprinting CharactersLiteral unprintable characters in strings.
Text Props and StringsStrings with text properties.
Editing Types
Buffer TypeThe basic object of editing.
Marker TypeA position in a buffer.
Window TypeBuffers are displayed in windows.
Frame TypeWindows subdivide frames.
Terminal TypeA terminal device displays frames.
Window Configuration TypeRecording the way a frame is subdivided.
Frame Configuration TypeRecording the status of all frames.
Process TypeA subprocess of Emacs running on the underlying OS.
Thread TypeA thread of Emacs Lisp execution.
Mutex TypeAn exclusive lock for thread synchronization.
Condition Variable TypeCondition variable for thread synchronization.
Stream TypeReceive or send characters.
Keymap TypeWhat function a keystroke invokes.
Overlay TypeHow an overlay is represented.
Font TypeFonts for displaying text.
Integer BasicsRepresentation and range of integers.
Float BasicsRepresentation and range of floating point.
Predicates on NumbersTesting for numbers.
Comparison of NumbersEquality and inequality predicates.
Numeric ConversionsConverting float to integer and vice versa.
Arithmetic OperationsHow to add, subtract, multiply and divide.
Rounding OperationsExplicitly rounding floating-point numbers.
Bitwise OperationsLogical and, or, not, shifting.
Math FunctionsTrig, exponential and logarithmic functions.
Random NumbersObtaining random integers, predictable or not.
Strings and Characters
String BasicsBasic properties of strings and characters.
Predicates for StringsTesting whether an object is a string or char.
Creating StringsFunctions to allocate new strings.
Modifying StringsAltering the contents of an existing string.
Text ComparisonComparing characters or strings.
String ConversionConverting to and from characters and strings.
Formatting Stringsformat: Emacs’s analogue of printf.
Case ConversionCase conversion functions.
Case TablesCustomizing case conversion.
Cons CellsHow lists are made out of cons cells.
List-related PredicatesIs this object a list? Comparing two lists.
List ElementsExtracting the pieces of a list.
Building ListsCreating list structure.
List VariablesModifying lists stored in variables.
Modifying ListsStoring new pieces into an existing list.
Sets And ListsA list can represent a finite mathematical set.
Association ListsA list can represent a finite relation or mapping.
Property ListsA list of paired elements.
Modifying Existing List Structure
SetcarReplacing an element in a list.
SetcdrReplacing part of the list backbone. This can be used to remove or add elements.
RearrangementReordering the elements in a list; combining lists.
Property Lists
Plists and AlistsComparison of the advantages of property lists and association lists.
Plist AccessAccessing property lists stored elsewhere.
Sequences, Arrays, and Vectors
Sequence FunctionsFunctions that accept any kind of sequence.
ArraysCharacteristics of arrays in Emacs Lisp.
Array FunctionsFunctions specifically for arrays.
VectorsSpecial characteristics of Emacs Lisp vectors.
Vector FunctionsFunctions specifically for vectors.
Char-TablesHow to work with char-tables.
Bool-VectorsHow to work with bool-vectors.
RingsManaging a fixed-size ring of objects.
Record FunctionsFunctions for records.
Backward CompatibilityCompatibility for cl-defstruct.
Hash Tables
Creating HashFunctions to create hash tables.
Hash AccessReading and writing the hash table contents.
Defining HashDefining new comparison methods.
Other HashMiscellaneous.
Symbol ComponentsSymbols have names, values, function definitions and property lists.
DefinitionsA definition says how a symbol will be used.
Creating SymbolsHow symbols are kept unique.
Symbol PropertiesEach symbol has a property list for recording miscellaneous information.
Symbol Properties
Symbol PlistsAccessing symbol properties.
Standard PropertiesStandard meanings of symbol properties.
Intro EvalEvaluation in the scheme of things.
FormsHow various sorts of objects are evaluated.
QuotingAvoiding evaluation (to put constants in the program).
BackquoteEasier construction of list structure.
EvalHow to invoke the Lisp interpreter explicitly.
Deferred EvalDeferred and lazy evaluation of forms.
Kinds of Forms
Self-Evaluating FormsForms that evaluate to themselves.
Symbol FormsSymbols evaluate as variables.
Classifying ListsHow to distinguish various sorts of list forms.
Function IndirectionWhen a symbol appears as the car of a list, we find the real function via the symbol.
Function FormsForms that call functions.
Macro FormsForms that call macros.
Special FormsSpecial forms are idiosyncratic primitives, most of them extremely important.
AutoloadingFunctions set up to load files containing their real definitions.
Control Structures
SequencingEvaluation in textual order.
Conditionalsif, cond, when, unless.
Combining Conditionsand, or, not.
Pattern-Matching ConditionalHow to use pcase and friends.
Iterationwhile loops.
GeneratorsGeneric sequences and coroutines.
Nonlocal ExitsJumping out of a sequence.
Nonlocal Exits
Catch and ThrowNonlocal exits for the program’s own purposes.
Examples of CatchShowing how such nonlocal exits can be written.
ErrorsHow errors are signaled and handled.
CleanupsArranging to run a cleanup form if an error happens.
Signaling ErrorsHow to report an error.
Processing of ErrorsWhat Emacs does when you report an error.
Handling ErrorsHow you can trap errors and continue execution.
Error SymbolsHow errors are classified for trapping them.
Global VariablesVariable values that exist permanently, everywhere.
Constant VariablesVariables that never change.
Local VariablesVariable values that exist only temporarily.
Void VariablesSymbols that lack values.
Defining VariablesA definition says a symbol is used as a variable.
Tips for DefiningThings you should think about when you define a variable.
Accessing VariablesExamining values of variables whose names are known only at run time.
Setting VariablesStoring new values in variables.
Watching VariablesRunning a function when a variable is changed.
Variable ScopingHow Lisp chooses among local and global values.
Buffer-Local VariablesVariable values in effect only in one buffer.
File Local VariablesHandling local variable lists in files.
Directory Local VariablesLocal variables common to all files in a directory.
Connection Local VariablesLocal variables common for remote connections.
Variable AliasesVariables that are aliases for other variables.
Variables with Restricted ValuesNon-constant variables whose value can not be an arbitrary Lisp object.
Generalized VariablesExtending the concept of variables.
Scoping Rules for Variable Bindings
Dynamic BindingThe default for binding local variables in Emacs.
Dynamic Binding TipsAvoiding problems with dynamic binding.
Lexical BindingA different type of local variable binding.
Using Lexical BindingHow to enable lexical binding.
Buffer-Local Variables
Intro to Buffer-LocalIntroduction and concepts.
Creating Buffer-LocalCreating and destroying buffer-local bindings.
Default ValueThe default value is seen in buffers that don’t have their own buffer-local values.
Generalized Variables
Setting Generalized VariablesThe setf macro.
Adding Generalized VariablesDefining new setf forms.
What Is a FunctionLisp functions vs. primitives; terminology.
Lambda ExpressionsHow functions are expressed as Lisp objects.
Function NamesA symbol can serve as the name of a function.
Defining FunctionsLisp expressions for defining functions.
Calling FunctionsHow to use an existing function.
Mapping FunctionsApplying a function to each element of a list, etc.
Anonymous FunctionsLambda expressions are functions with no names.
Generic FunctionsPolymorphism, Emacs-style.
Function CellsAccessing or setting the function definition of a symbol.
ClosuresFunctions that enclose a lexical environment.
Advising FunctionsAdding to the definition of a function.
Obsolete FunctionsDeclaring functions obsolete.
Inline FunctionsDefining functions that the compiler will expand inline.
Declare FormAdding additional information about a function.
Declaring FunctionsTelling the compiler that a function is defined.
Function SafetyDetermining whether a function is safe to call.
Related TopicsCross-references to specific Lisp primitives that have a special bearing on how functions work.
Lambda Expressions
Lambda ComponentsThe parts of a lambda expression.
Simple LambdaA simple example.
Argument ListDetails and special features of argument lists.
Function DocumentationHow to put documentation in a function.
Advising Emacs Lisp Functions
Core Advising PrimitivesPrimitives to manipulate advice.
Advising Named FunctionsAdvising named functions.
Advice CombinatorsWays to compose advice.
Porting Old AdviceAdapting code using the old defadvice.
Simple MacroA basic example.
ExpansionHow, when and why macros are expanded.
Compiling MacrosHow macros are expanded by the compiler.
Defining MacrosHow to write a macro definition.
Problems with MacrosDon’t evaluate the macro arguments too many times. Don’t hide the user’s variables.
Indenting MacrosSpecifying how to indent macro calls.
Common Problems Using Macros
Wrong TimeDo the work in the expansion, not in the macro.
Argument EvaluationThe expansion should evaluate each macro arg once.
Surprising Local VarsLocal variable bindings in the expansion require special care.
Eval During ExpansionDon’t evaluate them; put them in the expansion.
Repeated ExpansionAvoid depending on how many times expansion is done.
Customization Settings
Common KeywordsCommon keyword arguments for all kinds of customization declarations.
Group DefinitionsWriting customization group definitions.
Variable DefinitionsDeclaring user options.
Customization TypesSpecifying the type of a user option.
Applying CustomizationsFunctions to apply customization settings.
Custom ThemesWriting Custom themes.
Customization Types
Simple TypesSimple customization types: sexp, integer, etc.
Composite TypesBuild new types from other types or data.
Splicing into ListsSplice elements into list with :inline.
Type KeywordsKeyword-argument pairs in a customization type.
Defining New TypesGive your type a name.
How Programs Do LoadingThe load function and others.
Load SuffixesDetails about the suffixes that load tries.
Library SearchFinding a library to load.
Loading Non-ASCIINon-ASCII characters in Emacs Lisp files.
AutoloadSetting up a function to autoload.
Repeated LoadingPrecautions about loading a file twice.
Named FeaturesLoading a library if it isn’t already loaded.
Where DefinedFinding which file defined a certain symbol.
UnloadingHow to unload a library that was loaded.
Hooks for LoadingProviding code to be run when particular libraries are loaded.
Dynamic ModulesModules provide additional Lisp primitives.
Byte Compilation
Speed of Byte-CodeAn example of speedup from byte compilation.
Compilation FunctionsByte compilation functions.
Docs and CompilationDynamic loading of documentation strings.
Dynamic LoadingDynamic loading of individual functions.
Eval During CompileCode to be evaluated when you compile.
Compiler ErrorsHandling compiler error messages.
Byte-Code ObjectsThe data type used for byte-compiled functions.
DisassemblyDisassembling byte-code; how to read byte-code.
Debugging Lisp Programs
DebuggerA debugger for the Emacs Lisp evaluator.
EdebugA source-level Emacs Lisp debugger.
Syntax ErrorsHow to find syntax errors.
Test CoverageEnsuring you have tested all branches in your code.
ProfilingMeasuring the resources that your code uses.
The Lisp Debugger
Error DebuggingEntering the debugger when an error happens.
Infinite LoopsStopping and debugging a program that doesn’t exit.
Function DebuggingEntering it when a certain function is called.
Variable DebuggingEntering it when a variable is modified.
Explicit DebugEntering it at a certain point in the program.
Using DebuggerWhat the debugger does.
BacktracesWhat you see while in the debugger.
Debugger CommandsCommands used while in the debugger.
Invoking the DebuggerHow to call the function debug.
Internals of DebuggerSubroutines of the debugger, and global variables.
Using EdebugIntroduction to use of Edebug.
InstrumentingYou must instrument your code in order to debug it with Edebug.
Edebug Execution ModesExecution modes, stopping more or less often.
JumpingCommands to jump to a specified place.
Edebug MiscMiscellaneous commands.
BreaksSetting breakpoints to make the program stop.
Trapping ErrorsTrapping errors with Edebug.
Edebug ViewsViews inside and outside of Edebug.
Edebug EvalEvaluating expressions within Edebug.
Eval ListExpressions whose values are displayed each time you enter Edebug.
Printing in EdebugCustomization of printing.
Trace BufferHow to produce trace output in a buffer.
Coverage TestingHow to test evaluation coverage.
The Outside ContextData that Edebug saves and restores.
Edebug and MacrosSpecifying how to handle macro calls.
Edebug OptionsOption variables for customizing Edebug.
BreakpointsBreakpoints at stop points.
Global Break ConditionBreaking on an event.
Source BreakpointsEmbedding breakpoints in source code.
The Outside Context
Checking Whether to StopWhen Edebug decides what to do.
Edebug Display UpdateWhen Edebug updates the display.
Edebug Recursive EditWhen Edebug stops execution.
Edebug and Macros
Instrumenting Macro CallsThe basic problem.
Specification ListHow to specify complex patterns of evaluation.
BacktrackingWhat Edebug does when matching fails.
Specification ExamplesTo help understand specifications.
Debugging Invalid Lisp Syntax
Excess OpenHow to find a spurious open paren or missing close.
Excess CloseHow to find a spurious close paren or missing open.
Reading and Printing Lisp Objects
Streams IntroOverview of streams, reading and printing.
Input StreamsVarious data types that can be used as input streams.
Input FunctionsFunctions to read Lisp objects from text.
Output StreamsVarious data types that can be used as output streams.
Output FunctionsFunctions to print Lisp objects as text.
Output VariablesVariables that control what the printing functions do.
Intro to MinibuffersBasic information about minibuffers.
Text from MinibufferHow to read a straight text string.
Object from MinibufferHow to read a Lisp object or expression.
Minibuffer HistoryRecording previous minibuffer inputs so the user can reuse them.
Initial InputSpecifying initial contents for the minibuffer.
CompletionHow to invoke and customize completion.
Yes-or-No QueriesAsking a question with a simple answer.
Multiple QueriesAsking a series of similar questions.
Reading a PasswordReading a password from the terminal.
Minibuffer CommandsCommands used as key bindings in minibuffers.
Minibuffer WindowsOperating on the special minibuffer windows.
Minibuffer ContentsHow such commands access the minibuffer text.
Recursive MiniWhether recursive entry to minibuffer is allowed.
Minibuffer MiscVarious customization hooks and variables.
Basic CompletionLow-level functions for completing strings.
Minibuffer CompletionInvoking the minibuffer with completion.
Completion CommandsMinibuffer commands that do completion.
High-Level CompletionConvenient special cases of completion (reading buffer names, variable names, etc.).
Reading File NamesUsing completion to read file names and shell commands.
Completion VariablesVariables controlling completion behavior.
Programmed CompletionWriting your own completion function.
Completion in BuffersCompleting text in ordinary buffers.
Command Loop
Command OverviewHow the command loop reads commands.
Defining CommandsSpecifying how a function should read arguments.
Interactive CallCalling a command, so that it will read arguments.
Distinguish InteractiveMaking a command distinguish interactive calls.
Command Loop InfoVariables set by the command loop for you to examine.
Adjusting PointAdjustment of point after a command.
Input EventsWhat input looks like when you read it.
Reading InputHow to read input events from the keyboard or mouse.
Special EventsEvents processed immediately and individually.
WaitingWaiting for user input or elapsed time.
QuittingHow C-g works. How to catch or defer quitting.
Prefix Command ArgumentsHow the commands to set prefix args work.
Recursive EditingEntering a recursive edit, and why you usually shouldn’t.
Disabling CommandsHow the command loop handles disabled commands.
Command HistoryHow the command history is set up, and how accessed.
Keyboard MacrosHow keyboard macros are implemented.
Defining Commands
Using InteractiveGeneral rules for interactive.
Interactive CodesThe standard letter-codes for reading arguments in various ways.
Interactive ExamplesExamples of how to read interactive arguments.
Generic CommandsSelect among command alternatives.
Input Events
Keyboard EventsOrdinary characters – keys with symbols on them.
Function KeysFunction keys – keys with names, not symbols.
Mouse EventsOverview of mouse events.
Click EventsPushing and releasing a mouse button.
Drag EventsMoving the mouse before releasing the button.
Button-Down EventsA button was pushed and not yet released.
Repeat EventsDouble and triple click (or drag, or down).
Motion EventsJust moving the mouse, not pushing a button.
Focus EventsMoving the mouse between frames.
Misc EventsOther events the system can generate.
Event ExamplesExamples of the lists for mouse events.
Classifying EventsFinding the modifier keys in an event symbol. Event types.
Accessing MouseFunctions to extract info from mouse events.
Accessing ScrollFunctions to get info from scroll bar events.
Strings of EventsSpecial considerations for putting keyboard character events in a string.
Reading Input
Key Sequence InputHow to read one key sequence.
Reading One EventHow to read just one event.
Event ModHow Emacs modifies events as they are read.
Invoking the Input MethodHow reading an event uses the input method.
Quoted Character InputAsking the user to specify a character.
Event Input MiscHow to reread or throw away input events.
Key SequencesKey sequences as Lisp objects.
Keymap BasicsBasic concepts of keymaps.
Format of KeymapsWhat a keymap looks like as a Lisp object.
Creating KeymapsFunctions to create and copy keymaps.
Inheritance and KeymapsHow one keymap can inherit the bindings of another keymap.
Prefix KeysDefining a key with a keymap as its definition.
Active KeymapsHow Emacs searches the active keymaps for a key binding.
Searching KeymapsA pseudo-Lisp summary of searching active maps.
Controlling Active MapsEach buffer has a local keymap to override the standard (global) bindings. A minor mode can also override them.
Key LookupFinding a key’s binding in one keymap.
Functions for Key LookupHow to request key lookup.
Changing Key BindingsRedefining a key in a keymap.
Remapping CommandsA keymap can translate one command to another.
Translation KeymapsKeymaps for translating sequences of events.
Key Binding CommandsInteractive interfaces for redefining keys.
Scanning KeymapsLooking through all keymaps, for printing help.
Menu KeymapsDefining a menu as a keymap.
Menu Keymaps
Defining MenusHow to make a keymap that defines a menu.
Mouse MenusHow users actuate the menu with the mouse.
Keyboard MenusHow users actuate the menu with the keyboard.
Menu ExampleMaking a simple menu.
Menu BarHow to customize the menu bar.
Tool BarA tool bar is a row of images.
Modifying MenusHow to add new items to a menu.
Easy MenuA convenience macro for defining menus.
Defining Menus
Simple Menu ItemsA simple kind of menu key binding.
Extended Menu ItemsMore complex menu item definitions.
Menu SeparatorsDrawing a horizontal line through a menu.
Alias Menu ItemsUsing command aliases in menu items.
Major and Minor Modes
HooksHow to use hooks; how to write code that provides hooks.
Major ModesDefining major modes.
Minor ModesDefining minor modes.
Mode Line FormatCustomizing the text that appears in the mode line.
ImenuProviding a menu of definitions made in a buffer.
Font Lock ModeHow modes can highlight text according to syntax.
Auto-IndentationHow to teach Emacs to indent for a major mode.
Desktop Save ModeHow modes can have buffer state saved between Emacs sessions.
Running HooksHow to run a hook.
Setting HooksHow to put functions on a hook, or remove them.
Major Modes
Major Mode ConventionsCoding conventions for keymaps, etc.
Auto Major ModeHow Emacs chooses the major mode automatically.
Mode HelpFinding out how to use a mode.
Derived ModesDefining a new major mode based on another major mode.
Basic Major ModesModes that other modes are often derived from.
Mode HooksHooks run at the end of major mode functions.
Tabulated List ModeParent mode for buffers containing tabulated data.
Generic ModesDefining a simple major mode that supports comment syntax and Font Lock mode.
Example Major ModesText mode and Lisp modes.
Minor Modes
Minor Mode ConventionsTips for writing a minor mode.
Keymaps and Minor ModesHow a minor mode can have its own keymap.
Defining Minor ModesA convenient facility for defining minor modes.
Mode Line Format
Mode Line BasicsBasic ideas of mode line control.
Mode Line DataThe data structure that controls the mode line.
Mode Line TopThe top level variable, mode-line-format.
Mode Line VariablesVariables used in that data structure.
%-ConstructsPutting information into a mode line.
Properties in ModeUsing text properties in the mode line.
Header LinesLike a mode line, but at the top.
Emulating Mode LineFormatting text as the mode line would.
Font Lock Mode
Font Lock BasicsOverview of customizing Font Lock.
Search-based FontificationFontification based on regexps.
Customizing KeywordsCustomizing search-based fontification.
Other Font Lock VariablesAdditional customization facilities.
Levels of Font LockEach mode can define alternative levels so that the user can select more or less.
Precalculated FontificationHow Lisp programs that produce the buffer contents can also specify how to fontify it.
Faces for Font LockSpecial faces specifically for Font Lock.
Syntactic Font LockFontification based on syntax tables.
Multiline Font LockHow to coerce Font Lock into properly highlighting multiline constructs.
Multiline Font Lock Constructs
Font Lock MultilineMarking multiline chunks with a text property.
Region to RefontifyControlling which region gets refontified after a buffer change.
Automatic Indentation of code
SMIEA simple minded indentation engine.
Simple Minded Indentation Engine
SMIE setupSMIE setup and features.
Operator Precedence GrammarsA very simple parsing technique.
SMIE GrammarDefining the grammar of a language.
SMIE LexerDefining tokens.
SMIE TricksWorking around the parser’s limitations.
SMIE IndentationSpecifying indentation rules.
SMIE Indentation HelpersHelper functions for indentation rules.
SMIE Indentation ExampleSample indentation rules.
SMIE CustomizationCustomizing indentation.
Documentation BasicsWhere doc strings are defined and stored.
Accessing DocumentationHow Lisp programs can access doc strings.
Keys in DocumentationSubstituting current key bindings.
Text Quoting StyleQuotation marks in doc strings and messages.
Describing CharactersMaking printable descriptions of non-printing characters and key sequences.
Help FunctionsSubroutines used by Emacs help facilities.
Visiting FilesReading files into Emacs buffers for editing.
Saving BuffersWriting changed buffers back into files.
Reading from FilesReading files into buffers without visiting.
Writing to FilesWriting new files from parts of buffers.
File LocksLocking and unlocking files, to prevent simultaneous editing by two people.
Information about FilesTesting existence, accessibility, size of files.
Changing FilesRenaming files, changing permissions, etc.
File NamesDecomposing and expanding file names.
Contents of DirectoriesGetting a list of the files in a directory.
Create/Delete DirsCreating and Deleting Directories.
Magic File NamesSpecial handling for certain file names.
Format ConversionConversion to and from various file formats.
Visiting Files
Visiting FunctionsThe usual interface functions for visiting.
Subroutines of VisitingLower-level subroutines that they use.
Information about Files
Testing AccessibilityIs a given file readable? Writable?
Kinds of FilesIs it a directory? A symbolic link?
TruenamesEliminating symbolic links from a file name.
File AttributesFile sizes, modification times, etc.
Extended AttributesExtended file attributes for access control.
Locating FilesHow to find a file in standard places.
File Names
File Name ComponentsThe directory part of a file name, and the rest.
Relative File NamesSome file names are relative to a current directory.
Directory NamesA directory’s name as a directory is different from its name as a file.
File Name ExpansionConverting relative file names to absolute ones.
Unique File NamesGenerating names for temporary files.
File Name CompletionFinding the completions for a given file name.
Standard File NamesIf your package uses a fixed file name, how to handle various operating systems simply.
File Format Conversion
Format Conversion Overviewinsert-file-contents and write-region.
Format Conversion Round-TripUsing format-alist.
Format Conversion PiecemealSpecifying non-paired conversion.
Backups and Auto-Saving
Backup FilesHow backup files are made; how their names are chosen.
Auto-SavingHow auto-save files are made; how their names are chosen.
Revertingrevert-buffer, and how to customize what it does.
Backup Files
Making BackupsHow Emacs makes backup files, and when.
Rename or CopyTwo alternatives: renaming the old file or copying it.
Numbered BackupsKeeping multiple backups for each source file.
Backup NamesHow backup file names are computed; customization.
Buffer BasicsWhat is a buffer?
Current BufferDesignating a buffer as current so that primitives will access its contents.
Buffer NamesAccessing and changing buffer names.
Buffer File NameThe buffer file name indicates which file is visited.
Buffer ModificationA buffer is modified if it needs to be saved.
Modification TimeDetermining whether the visited file was changed behind Emacs’s back.
Read Only BuffersModifying text is not allowed in a read-only buffer.
Buffer ListHow to look at all the existing buffers.
Creating BuffersFunctions that create buffers.
Killing BuffersBuffers exist until explicitly killed.
Indirect BuffersAn indirect buffer shares text with some other buffer.
Swapping TextSwapping text between two buffers.
Buffer GapThe gap in the buffer.
Basic WindowsBasic information on using windows.
Windows and FramesRelating windows to the frame they appear on.
Window SizesAccessing a window’s size.
Resizing WindowsChanging the sizes of windows.
Preserving Window SizesPreserving the size of windows.
Splitting WindowsSplitting one window into two windows.
Deleting WindowsDeleting a window gives its space to other windows.
Recombining WindowsPreserving the frame layout when splitting and deleting windows.
Selecting WindowsThe selected window is the one that you edit in.
Cyclic Window OrderingMoving around the existing windows.
Buffers and WindowsEach window displays the contents of a buffer.
Switching BuffersHigher-level functions for switching to a buffer.
Displaying BuffersDisplaying a buffer in a suitable window.
Window HistoryEach window remembers the buffers displayed in it.
Dedicated WindowsHow to avoid displaying another buffer in a specific window.
Quitting WindowsHow to restore the state prior to displaying a buffer.
Side WindowsSpecial windows on a frame’s sides.
Atomic WindowsPreserving parts of the window layout.
Window PointEach window has its own location of point.
Window Start and EndBuffer positions indicating which text is on-screen in a window.
Textual ScrollingMoving text up and down through the window.
Vertical ScrollingMoving the contents up and down on the window.
Horizontal ScrollingMoving the contents sideways on the window.
Coordinates and WindowsConverting coordinates to windows.
Mouse Window Auto-selectionAutomatically selecting windows with the mouse.
Window ConfigurationsSaving and restoring the state of the screen.
Window ParametersAssociating additional information with windows.
Window HooksHooks for scrolling, window size changes, redisplay going past a certain point, or window configuration changes.
Displaying Buffers
Choosing WindowHow to choose a window for displaying a buffer.
Buffer Display Action FunctionsSupport functions for buffer display.
Buffer Display Action AlistsAlists for fine-tuning buffer display action functions.
Choosing Window OptionsExtra options affecting how buffers are displayed.
Precedence of Action FunctionsA tutorial explaining the precedence of buffer display action functions.
The Zen of Buffer DisplayHow to avoid that buffers get lost in between windows.
Side Windows
Displaying Buffers in Side WindowsAn action function for displaying buffers in side windows.
Side Window Options and FunctionsFurther tuning of side windows.
Frame Layouts with Side WindowsSetting up frame layouts with side windows.
Creating FramesCreating additional frames.
Multiple TerminalsDisplaying on several different devices.
Frame GeometryGeometric properties of frames.
Frame ParametersControlling frame size, position, font, etc.
Terminal ParametersParameters common for all frames on terminal.
Frame TitlesAutomatic updating of frame titles.
Deleting FramesFrames last until explicitly deleted.
Finding All FramesHow to examine all existing frames.
Minibuffers and FramesHow a frame finds the minibuffer to use.
Input FocusSpecifying the selected frame.
Visibility of FramesFrames may be visible or invisible, or icons.
Raising and LoweringRaising, Lowering and Restacking Frames.
Frame ConfigurationsSaving the state of all frames.
Child FramesMaking a frame the child of another.
Mouse TrackingGetting events that say when the mouse moves.
Mouse PositionAsking where the mouse is, or moving it.
Pop-Up MenusDisplaying a menu for the user to select from.
Dialog BoxesDisplaying a box to ask yes or no.
Pointer ShapeSpecifying the shape of the mouse pointer.
Window System SelectionsTransferring text to and from other X clients.
Drag and DropInternals of Drag-and-Drop implementation.
Color NamesGetting the definitions of color names.
Text Terminal ColorsDefining colors for text terminals.
ResourcesGetting resource values from the server.
Display Feature TestingDetermining the features of a terminal.
Frame Geometry
Frame LayoutBasic layout of frames.
Frame FontThe default font of a frame and how to set it.
Frame PositionThe position of a frame on its display.
Frame SizeSpecifying and retrieving a frame’s size.
Implied Frame ResizingImplied resizing of frames and how to prevent it.
Frame Parameters
Parameter AccessHow to change a frame’s parameters.
Initial ParametersSpecifying frame parameters when you make a frame.
Window Frame ParametersList of frame parameters for window systems.
GeometryParsing geometry specifications.
Window Frame Parameters
Basic ParametersParameters that are fundamental.
Position ParametersThe position of the frame on the screen.
Size ParametersFrame’s size.
Layout ParametersSize of parts of the frame, and enabling or disabling some parts.
Buffer ParametersWhich buffers have been or should be shown.
Frame Interaction ParametersParameters for interacting with other frames.
Mouse Dragging ParametersParameters for resizing and moving frames with the mouse.
Management ParametersCommunicating with the window manager.
Cursor ParametersControlling the cursor appearance.
Font and Color ParametersFonts and colors for the frame text.
PointThe special position where editing takes place.
MotionChanging point.
ExcursionsTemporary motion and buffer changes.
NarrowingRestricting editing to a portion of the buffer.
Character MotionMoving in terms of characters.
Word MotionMoving in terms of words.
Buffer End MotionMoving to the beginning or end of the buffer.
Text LinesMoving in terms of lines of text.
Screen LinesMoving in terms of lines as displayed.
List MotionMoving by parsing lists and sexps.
Skipping CharactersSkipping characters belonging to a certain set.
Overview of MarkersThe components of a marker, and how it relocates.
Predicates on MarkersTesting whether an object is a marker.
Creating MarkersMaking empty markers or markers at certain places.
Information from MarkersFinding the marker’s buffer or character position.
Marker Insertion TypesTwo ways a marker can relocate when you insert where it points.
Moving MarkersMoving the marker to a new buffer or position.
The MarkHow the mark is implemented with a marker.
The RegionHow to access the region.
Near PointExamining text in the vicinity of point.
Buffer ContentsExamining text in a general fashion.
Comparing TextComparing substrings of buffers.
InsertionAdding new text to a buffer.
Commands for InsertionUser-level commands to insert text.
DeletionRemoving text from a buffer.
User-Level DeletionUser-level commands to delete text.
The Kill RingWhere removed text sometimes is saved for later use.
UndoUndoing changes to the text of a buffer.
Maintaining UndoHow to enable and disable undo information. How to control how much information is kept.
FillingFunctions for explicit filling.
MarginsHow to specify margins for filling commands.
Adaptive FillAdaptive Fill mode chooses a fill prefix from context.
Auto FillingHow auto-fill mode is implemented to break lines.
SortingFunctions for sorting parts of the buffer.
ColumnsComputing horizontal positions, and using them.
IndentationFunctions to insert or adjust indentation.
Case ChangesCase conversion of parts of the buffer.
Text PropertiesAssigning Lisp property lists to text characters.
SubstitutionReplacing a given character wherever it appears.
RegistersHow registers are implemented. Accessing the text or position stored in a register.
TranspositionSwapping two portions of a buffer.
DecompressionDealing with compressed data.
Base 64Conversion to or from base 64 encoding.
Checksum/HashComputing cryptographic hashes.
GnuTLS CryptographyCryptographic algorithms imported from GnuTLS.
Parsing HTML/XMLParsing HTML and XML.
Atomic ChangesInstalling several buffer changes atomically.
Change HooksSupplying functions to be run when text is changed.
The Kill Ring
Kill Ring ConceptsWhat text looks like in the kill ring.
Kill FunctionsFunctions that kill text.
YankingHow yanking is done.
Yank CommandsCommands that access the kill ring.
Low-Level Kill RingFunctions and variables for kill ring access.
Internals of Kill RingVariables that hold kill ring data.
Primitive IndentFunctions used to count and insert indentation.
Mode-Specific IndentCustomize indentation for different modes.
Region IndentIndent all the lines in a region.
Relative IndentIndent the current line based on previous lines.
Indent TabsAdjustable, typewriter-like tab stops.
Motion by IndentMove to first non-blank character.
Text Properties
Examining PropertiesLooking at the properties of one character.
Changing PropertiesSetting the properties of a range of text.
Property SearchSearching for where a property changes value.
Special PropertiesParticular properties with special meanings.
Format PropertiesProperties for representing formatting of text.
Sticky PropertiesHow inserted text gets properties from neighboring text.
Lazy PropertiesComputing text properties in a lazy fashion only when text is examined.
Clickable TextUsing text properties to make regions of text do something when you click on them.
FieldsThe field property defines fields within the buffer.
Not IntervalsWhy text properties do not use Lisp-visible text intervals.
Parsing HTML and XML
Document Object ModelAccess, manipulate and search the DOM.
Non-ASCII Characters
Text RepresentationsHow Emacs represents text.
Disabling MultibyteControlling whether to use multibyte characters.
Converting RepresentationsConverting unibyte to multibyte and vice versa.
Selecting a RepresentationTreating a byte sequence as unibyte or multi.
Character CodesHow unibyte and multibyte relate to codes of individual characters.
Character PropertiesCharacter attributes that define their behavior and handling.
Character SetsThe space of possible character codes is divided into various character sets.
Scanning CharsetsWhich character sets are used in a buffer?
Translation of CharactersTranslation tables are used for conversion.
Coding SystemsCoding systems are conversions for saving files.
Input MethodsInput methods allow users to enter various non-ASCII characters without special keyboards.
LocalesInteracting with the POSIX locale.
Coding Systems
Coding System BasicsBasic concepts.
Encoding and I/OHow file I/O functions handle coding systems.
Lisp and Coding SystemsFunctions to operate on coding system names.
User-Chosen Coding SystemsAsking the user to choose a coding system.
Default Coding SystemsControlling the default choices.
Specifying Coding SystemsRequesting a particular coding system for a single file operation.
Explicit EncodingEncoding or decoding text without doing I/O.
Terminal I/O EncodingUse of encoding for terminal I/O.
Searching and Matching
String SearchSearch for an exact match.
Searching and CaseCase-independent or case-significant searching.
Regular ExpressionsDescribing classes of strings.
Regexp SearchSearching for a match for a regexp.
POSIX RegexpsSearching POSIX-style for the longest match.
Match DataFinding out which part of the text matched, after a string or regexp search.
Search and ReplaceCommands that loop, searching and replacing.
Standard RegexpsUseful regexps for finding sentences, pages,...
Regular Expressions
Syntax of RegexpsRules for writing regular expressions.
Regexp ExampleIllustrates regular expression syntax.
Rx NotationAn alternative, structured regexp notation.
Regexp FunctionsFunctions for operating on regular expressions.
Syntax of Regular Expressions
Regexp SpecialSpecial characters in regular expressions.
Char ClassesCharacter classes used in regular expressions.
Regexp BackslashBackslash-sequences in regular expressions.
The Match Data
Replacing MatchReplacing a substring that was matched.
Simple Match DataAccessing single items of match data, such as where a particular subexpression started.
Entire Match DataAccessing the entire match data at once, as a list.
Saving Match DataSaving and restoring the match data.
Syntax Tables
Syntax BasicsBasic concepts of syntax tables.
Syntax DescriptorsHow characters are classified.
Syntax Table FunctionsHow to create, examine and alter syntax tables.
Syntax PropertiesOverriding syntax with text properties.
Motion and SyntaxMoving over characters with certain syntaxes.
Parsing ExpressionsParsing balanced expressions using the syntax table.
Syntax Table InternalsHow syntax table information is stored.
CategoriesAnother way of classifying character syntax.
Syntax Descriptors
Syntax Class TableTable of syntax classes.
Syntax FlagsAdditional flags each character can have.
Parsing Expressions
Motion via ParsingMotion functions that work by parsing.
Position ParseDetermining the syntactic state of a position.
Parser StateHow Emacs represents a syntactic state.
Low-Level ParsingParsing across a specified region.
Control ParsingParameters that affect parsing.
Abbrevs and Abbrev Expansion
Abbrev TablesCreating and working with abbrev tables.
Defining AbbrevsSpecifying abbreviations and their expansions.
Abbrev FilesSaving abbrevs in files.
Abbrev ExpansionControlling expansion; expansion subroutines.
Standard Abbrev TablesAbbrev tables used by various major modes.
Abbrev PropertiesHow to read and set abbrev properties. Which properties have which effect.
Abbrev Table PropertiesHow to read and set abbrev table properties. Which properties have which effect.
Basic Thread FunctionsBasic thread functions.
MutexesMutexes allow exclusive access to data.
Condition VariablesInter-thread events.
The Thread ListShow the active threads.
Subprocess CreationFunctions that start subprocesses.
Shell ArgumentsQuoting an argument to pass it to a shell.
Synchronous ProcessesDetails of using synchronous subprocesses.
Asynchronous ProcessesStarting up an asynchronous subprocess.
Deleting ProcessesEliminating an asynchronous subprocess.
Process InformationAccessing run-status and other attributes.
Input to ProcessesSending input to an asynchronous subprocess.
Signals to ProcessesStopping, continuing or interrupting an asynchronous subprocess.
Output from ProcessesCollecting output from an asynchronous subprocess.
SentinelsSentinels run when process run-status changes.
Query Before ExitWhether to query if exiting will kill a process.
System ProcessesAccessing other processes running on your system.
Transaction QueuesTransaction-based communication with subprocesses.
NetworkOpening network connections.
Network ServersNetwork servers let Emacs accept net connections.
DatagramsUDP network connections.
Low-Level NetworkLower-level but more general function to create connections and servers.
Misc NetworkAdditional relevant functions for net connections.
Serial PortsCommunicating with serial ports.
Byte PackingUsing bindat to pack and unpack binary data.
Receiving Output from Processes
Process BuffersBy default, output is put in a buffer.
Filter FunctionsFilter functions accept output from the process.
Decoding OutputFilters can get unibyte or multibyte strings.
Accepting OutputHow to wait until process output arrives.
Low-Level Network Access
Network ProcessesUsing make-network-process.
Network OptionsFurther control over network connections.
Network Feature TestingDetermining which network features work on the machine you are using.
Packing and Unpacking Byte Arrays
Bindat SpecDescribing data layout.
Bindat FunctionsDoing the unpacking and packing.
Emacs Display
Refresh ScreenClearing the screen and redrawing everything on it.
Forcing RedisplayForcing redisplay.
TruncationFolding or wrapping long text lines.
The Echo AreaDisplaying messages at the bottom of the screen.
WarningsDisplaying warning messages for the user.
Invisible TextHiding part of the buffer text.
Selective DisplayHiding part of the buffer text (the old way).
Temporary DisplaysDisplays that go away automatically.
OverlaysUse overlays to highlight parts of the buffer.
Size of Displayed TextHow large displayed text is.
Line HeightControlling the height of lines.
FacesA face defines a graphics style for text characters: font, colors, etc.
FringesControlling window fringes.
Scroll BarsControlling scroll bars.
Window DividersSeparating windows visually.
Display PropertyEnabling special display features.
ImagesDisplaying images in Emacs buffers.
ButtonsAdding clickable buttons to Emacs buffers.
Abstract DisplayEmacs’s Widget for Object Collections.
BlinkingHow Emacs shows the matching open parenthesis.
Character DisplayHow Emacs displays individual characters.
BeepingAudible signal to the user.
Window SystemsWhich window system is being used.
TooltipsTooltip display in Emacs.
Bidirectional DisplayDisplay of bidirectional scripts, such as Arabic and Farsi.
The Echo Area
Displaying MessagesExplicitly displaying text in the echo area.
ProgressInforming user about progress of a long operation.
Logging MessagesEcho area messages are logged for the user.
Echo Area CustomizationControlling the echo area.
Reporting Warnings
Warning BasicsWarnings concepts and functions to report them.
Warning VariablesVariables programs bind to customize their warnings.
Warning OptionsVariables users set to control display of warnings.
Delayed WarningsDeferring a warning until the end of a command.
Managing OverlaysCreating and moving overlays.
Overlay PropertiesHow to read and set properties. What properties do to the screen display.
Finding OverlaysSearching for overlays.
Face AttributesWhat is in a face?
Defining FacesHow to define a face.
Attribute FunctionsFunctions to examine and set face attributes.
Displaying FacesHow Emacs combines the faces specified for a character.
Face RemappingRemapping faces to alternative definitions.
Face FunctionsHow to define and examine faces.
Auto FacesHook for automatic face assignment.
Basic FacesFaces that are defined by default.
Font SelectionFinding the best available font for a face.
Font LookupLooking up the names of available fonts and information about them.
FontsetsA fontset is a collection of fonts that handle a range of character sets.
Low-Level FontLisp representation for character display fonts.
Fringe Size/PosSpecifying where to put the window fringes.
Fringe IndicatorsDisplaying indicator icons in the window fringes.
Fringe CursorsDisplaying cursors in the right fringe.
Fringe BitmapsSpecifying bitmaps for fringe indicators.
Customizing BitmapsSpecifying your own bitmaps to use in the fringes.
Overlay ArrowDisplay of an arrow to indicate position.
The display Property
Replacing SpecsDisplay specs that replace the text.
Specified SpaceDisplaying one space with a specified width.
Pixel SpecificationSpecifying space width or height in pixels.
Other Display SpecsDisplaying an image; adjusting the height, spacing, and other properties of text.
Display MarginsDisplaying text or images to the side of the main text.
Image FormatsSupported image formats.
Image DescriptorsHow to specify an image for use in :display.
XBM ImagesSpecial features for XBM format.
XPM ImagesSpecial features for XPM format.
ImageMagick ImagesSpecial features available through ImageMagick.
Other Image TypesVarious other formats are supported.
Defining ImagesConvenient ways to define an image for later use.
Showing ImagesConvenient ways to display an image once it is defined.
Multi-Frame ImagesSome images contain more than one frame.
Image CacheInternal mechanisms of image display.
Button PropertiesButton properties with special meanings.
Button TypesDefining common properties for classes of buttons.
Making ButtonsAdding buttons to Emacs buffers.
Manipulating ButtonsGetting and setting properties of buttons.
Button Buffer CommandsBuffer-wide commands and bindings for buttons.
Abstract Display
Abstract Display FunctionsFunctions in the Ewoc package.
Abstract Display ExampleExample of using Ewoc.
Character Display
Usual DisplayThe usual conventions for displaying characters.
Display TablesWhat a display table consists of.
Active Display TableHow Emacs selects a display table to use.
GlyphsHow to define a glyph, and what glyphs mean.
Glyphless CharsHow glyphless characters are drawn.
Operating System Interface
Starting UpCustomizing Emacs startup processing.
Getting OutHow exiting works (permanent or temporary).
System EnvironmentDistinguish the name and kind of system.
User IdentificationFinding the name and user id of the user.
Time of DayGetting the current time.
Time ConversionConverting among timestamp forms.
Time ParsingConverting timestamps to text and vice versa.
Processor Run TimeGetting the run time used by Emacs.
Time CalculationsAdding, subtracting, comparing times, etc.
TimersSetting a timer to call a function at a certain time.
Idle TimersSetting a timer to call a function when Emacs has been idle for a certain length of time.
Terminal InputAccessing and recording terminal input.
Terminal OutputControlling and recording terminal output.
Sound OutputPlaying sounds on the computer’s speaker.
X11 KeysymsOperating on key symbols for X Windows.
Batch ModeRunning Emacs without terminal interaction.
Session ManagementSaving and restoring state with X Session Management.
Desktop NotificationsDesktop notifications.
File NotificationsFile notifications.
Dynamic LibrariesOn-demand loading of support libraries.
Security ConsiderationsRunning Emacs in an unfriendly environment.
Starting Up Emacs
Startup SummarySequence of actions Emacs performs at startup.
Init FileDetails on reading the init file.
Terminal-SpecificHow the terminal-specific Lisp file is read.
Command-Line ArgumentsHow command-line arguments are processed, and how you can customize them.
Getting Out of Emacs
Killing EmacsExiting Emacs irreversibly.
Suspending EmacsExiting Emacs reversibly.
Terminal Input
Input ModesOptions for how input is processed.
Recording InputSaving histories of recent or all input events.
Preparing Lisp code for distribution
Packaging BasicsThe basic concepts of Emacs Lisp packages.
Simple PackagesHow to package a single .el file.
Multi-file PackagesHow to package multiple files.
Package ArchivesMaintaining package archives.
Tips and Conventions
Coding ConventionsConventions for clean and robust programs.
Key Binding ConventionsWhich keys should be bound by which programs.
Programming TipsMaking Emacs code fit smoothly in Emacs.
Compilation TipsMaking compiled code run fast.
Warning TipsTurning off compiler warnings.
Documentation TipsWriting readable documentation strings.
Comment TipsConventions for writing comments.
Library HeadersStandard headers for library packages.
GNU Emacs Internals
Building EmacsHow the dumped Emacs is made.
Pure StorageKludge to make preloaded Lisp functions shareable.
Garbage CollectionReclaiming space for Lisp objects no longer used.
Stack-allocated ObjectsTemporary conses and strings on C stack.
Memory UsageInfo about total size of Lisp objects made so far.
C DialectWhat C variant Emacs is written in.
Writing Emacs PrimitivesWriting C code for Emacs.
Writing Dynamic ModulesWriting loadable modules for Emacs.
Object InternalsData formats of buffers, windows, processes.
C Integer TypesHow C integer types are used inside Emacs.
Writing Dynamic Modules
Module Initialization
Module Functions
Module Values
Module Misc
Module Nonlocal
Object Internals
Buffer InternalsComponents of a buffer structure.
Window InternalsComponents of a window structure.
Process InternalsComponents of a process structure.