Fact-checked by Grok 2 weeks ago

XEmacs

XEmacs is a powerful, extensible, and highly customizable and , forked from in 1991 to emphasize enhancements and modular package management. Originating as Lucid Emacs, a branch of 19 developed by the Lucid company for improved GUI support including mouse integration, multiple fonts, and window management, it was renamed XEmacs in 1994 following Lucid's closure, with key contributions from developers like and Ben Wing. The project introduced innovative features such as the (Multilingual Enhancement) system in 1997 for better internationalization support, native Windows ports between 1997 and 2000, and a pioneering package system in 1997 that allows independent updates to Lisp extensions without full core rebuilds. These advancements positioned XEmacs as a leader in Emacs variants for graphical and cross-platform usability, supporting image formats like , , and , and multi-device environments. While development slowed after the stable release of 21.4.22 in January 2009, the project saw a revival with releases resuming in 2023 after nearly a decade of . The latest , 21.5.36 "leeks," was released on June 14, 2025, incorporating ongoing improvements to the development trunk. Licensed under the GNU General Public License, XEmacs remains available for systems, Windows, and other platforms, appealing to users seeking a feature-rich alternative to with its emphasis on modularity and visual extensibility.

History

Origins as Lucid Emacs

Lucid Inc., a company specializing in C++ and Lisp development environments, initiated the development of Lucid Emacs in 1991 to create a more (GUI)-oriented variant of tailored for their software tools, particularly the Energize C++ . At the time, the standard GNU Emacs version 18.5 lacked essential GUI features such as mouse support, multiple fonts, and proper window-system integration, prompting Lucid to enhance the editor as a cornerstone for their commercial product suite. This effort aimed to provide a robust, customizable with advanced visual capabilities to improve developer productivity in a graphical computing landscape dominated by the . The initial development of Lucid Emacs was led by , along with early contributors including Matthieu Devin, Harlan Sexton, and Eric Benson, with a primary focus on seamless integration with the . Building on the existing Emacs codebase, the team prioritized enhancements that would enable Emacs to function effectively as a native X application, including support for graphical widgets and improved event handling for mouse and keyboard interactions. Zawinski, who became known as the primary maintainer, drove much of the core implementation, ensuring the editor could handle complex graphical operations without compromising its extensible Lisp-based architecture. Lucid Emacs 19.0 was released in 1992 as a pre-release derived from the beta version of 19, reflecting the parallel development paths taken due to delays in the Foundation's official release and the need for immediate GUI advancements. This fork allowed Lucid to incorporate experimental features from the GNU beta while addressing integration challenges specific to their commercial needs, marking the first major step toward a distinct lineage optimized for graphical environments. Among the key early innovations in Lucid Emacs 19.0 were improved support, which enabled the creation of reusable graphical components for user interfaces, and integration with the toolkit, providing a consistent with contemporary X-based applications. These additions facilitated more intuitive interactions, such as drag-and-drop operations and dialog boxes, setting the foundation for future enhancements in Emacs's graphical capabilities.

Forking from GNU Emacs

In late 1991, Lucid Emacs was forked from unreleased sources of 19 due to mounting disagreements between Lucid Inc. developers and the (FSF) over the pace of (GUI) integration and code management practices. Lucid, building on its earlier involvement in Emacs enhancements for the Energize C++ development environment, sought to accelerate support for features like mouse-driven menus, scrollbars, and multiple fonts to align with emerging standards, which were lagging in the FSF's development timeline. Meanwhile, FSF maintainers, including , prioritized backward compatibility and a more deliberate integration process, viewing Lucid's rapid changes as potentially destabilizing the codebase. Richard Stallman played a central role in the opposition, rejecting several of Lucid's proposed modifications to the unreleased Emacs 19 sources, which had been shared under the expectation of collaborative input. Stallman argued that the changes, developed without sufficient FSF oversight after a maintainer defected to Lucid in 1990, risked fragmenting the Emacs user base and violating design principles centered on extensibility through Lisp. This resistance culminated in Lucid's decision to pursue independent development in late 1991, forking the codebase to maintain momentum for their commercial needs while refusing to merge back without accepting their alterations wholesale. Despite Lucid's commercial backing, the forked Lucid Emacs was initially distributed as under the GNU General Public License (GPL), ensuring compatibility with the FSF's ethos and broadening its appeal beyond proprietary use. The first public releases emerged in 1992, starting with Lucid Emacs 19.0 in April, followed by 19.1 and 19.2 in June, which introduced enhanced capabilities and garnered quick adoption among users frustrated with delays. These early versions, primarily authored by developers like , Matthieu Devin, and Harlan Sexton, fostered a growing community around the , setting the stage for its evolution.

Renaming and Expansion

In 1994, following the cessation of support from Lucid Inc., the project originally known as Lucid Emacs was renamed to XEmacs through an agreement between and Lucid, with the first release under the new branding being version 19.11 on September 13, 1994. The renaming aimed to remove corporate affiliations while highlighting the editor's advanced integration with the for graphical environments. The development team expanded significantly during this period, transitioning from corporate backing to a broader collaborative effort. Ben Wing, who had joined in late 1992 as a primary architect and code contributor, played a central role, alongside , who led enhancements from versions 19.11 to 19.14. By the mid-1990s, additional contributors such as Steve Baur, who served as release engineer starting in 1996, and Hrvoje Nikšić, who became prominent from 1997 onward, further diversified the team's expertise and fostered ongoing innovation. Key milestones included the release of XEmacs 19.13 in September 1995, which introduced a new redisplay engine for improved graphical performance and initial (MULtilingual Enhancement to Emacs) support for handling non-Latin scripts. This was followed by XEmacs 20.0 in February 1997, which fully integrated robust multilingual capabilities, enabling better support for Asian languages and on Unix platforms. Throughout the 1990s, XEmacs experienced growth in its user base among developers on Unix workstations, particularly those favoring its superior features over terminal-based alternatives, which in turn spurred greater community involvement in the ecosystem.

Relationship to GNU Emacs

Philosophical Differences

The philosophical differences between XEmacs and arose primarily from divergent priorities in development , with XEmacs favoring rapid through a decentralized, community-oriented approach often described as the "" model, which encouraged frequent releases and integration of user-contributed enhancements like graphical interfaces and modular packages. In opposition, under Richard Stallman's leadership adhered to a "" model, emphasizing stability, rigorous centralized oversight, and controlled evolution to preserve compatibility and reliability within the broader . This contrast was evident from the fork, when Lucid developers initiated XEmacs (then Lucid Emacs) amid frustrations with 19's protracted development. A key point of contention in the involved debates over licensing purity and the perceived promotion of non-free tools. Stallman objected to Lucid Emacs announcements that highlighted proprietary Lucid products, viewing them as undermining ideals by blending commercial interests with GPL-licensed code, which led to restrictions on posting such updates to mailing lists. Despite these criticisms, XEmacs maintained full compliance with the GNU General Public License (GPL), ensuring its code remained freely distributable and modifiable. Stallman repeatedly advocated for project unification to foster and avoid community fragmentation, stating that "the whole loses when someone chooses rather than ." XEmacs maintainers, however, championed a modular and toolkit-agnostic design philosophy that prioritized extensibility and adaptability over unified control, allowing developers greater freedom to experiment without mandatory alignment to FSF guidelines. These ideological splits influenced principles by highlighting tensions between centralized guardianship of the GPL—exemplified by ' requirement for copyright assignments to the —and XEmacs' more permissive model of community-driven extensibility, which still adhered to GPL terms but diverged in to promote broader participation. The result was a lasting demonstration of how differing visions on control versus openness could coexist within the ecosystem without compromising core licensing commitments.

Technical Distinctions

One of the primary technical distinctions between XEmacs and lies in their implementations of the interpreter. XEmacs employs a more object-oriented design, treating characters, events, and keymaps as first-class opaque types rather than integers or lists as in versions 19 and 20, which enhances and performance in handling editor-specific data. This approach includes optimizations in the runtime, such as specialized objects for buffers optimized for insertion and deletion operations. In contrast, maintains a unified interpreter model where such elements are represented more simply, potentially leading to less overhead but reduced abstraction. Regarding bytecode, XEmacs and both compile to bytecode for execution by a dedicated interpreter, but their formats are incompatible due to differences in the underlying object models and compiler implementations. XEmacs includes byte-compilation enhancements, such as those contributed by Martin Buchholz, allowing for a separate handling of uncompiled .el files alongside compiled .elc files to facilitate user modifications without full recompilation. This divergence means bytecode files (.elc) generated for one cannot be loaded in the other, complicating package portability and requiring source-level compatibility checks. The buffer and display engines in XEmacs diverge significantly from , reflecting architectural choices for greater flexibility. XEmacs represents buffers as character arrays with extents—a unifying for text properties and overlays—enabling efficient manipulation and copying of properties into strings, whereas uses separate mechanisms for text properties (attached directly to characters) and overlays (floating ranges). The display engine in XEmacs, developed by for redisplay and Ben Wing for glyphs and specifiers, supports dynamic rendering with variable-width proportional fonts and full face support (e.g., ) even in console mode. , by comparison, relies on fixed-width fonts and raw Xlib calls for graphics, limiting toolkit integration. XEmacs integrates more seamlessly with widget toolkits like Xt (supporting and ) and has experimental + support since version 21.2, allowing embedding in external widgets and more responsive GUI elements such as iconic toolbars. Package formats and Elisp extensions further highlight incompatibilities, stemming from these core differences. XEmacs features a hierarchical package system with dedicated directories (e.g., xemacs-packages, mule-packages) and integrated tools like EFS for remote downloading and , bundling more libraries by default than early releases. Elisp extensions in XEmacs leverage extents for property handling, providing a superset interface compatible with GNU's text properties and overlays but with underlying differences that break direct interchangeability of code relying on internal representations. These extensions, combined with incompatibilities, make merging packages between the two editors challenging, often requiring dual maintenance or conditional code. In handling Unicode and internationalization, XEmacs adopted the (MULtilingual Enhancement) system earlier and more comprehensively than . Originating as an extension to for Asian-language support, Mule was integrated into XEmacs starting from version 19.14, with full support achieved in version 21.5 via Mule-UCS, including partial implementation in 21.4. XEmacs supports a broader range of input methods, such as XIM, Wnn, Canna, and SJ3, compared to 's primary reliance on XIM in earlier versions. However, divergences arose in later standards; while both now support internally, XEmacs's Mule variants (handling three kinds) and package hierarchies for differ from 's evolution through Mule 3 and 4, leading to variant-specific incompatibilities in file encoding and display.

Core Features

Graphical Interface Enhancements

XEmacs was designed with native integration to the X11 windowing system from its inception as Lucid Emacs in the early , enabling seamless graphical operation without relying on terminal emulators. This integration utilized the MIT X Toolkit Intrinsics (Xt) to abstract low-level Xlib calls, promoting better portability and "X citizenship" across diverse X11 environments. The editor supports multiple widget toolkits for its , including for a professional look, (via generic Xt) for lightweight rendering, and (with improvements to GTK 3.X support in recent 21.5 betas). These toolkits facilitate advanced interface elements such as configurable menubars, toolbars (positionable on top, bottom, left, or right), and vertical or horizontal scrollbars, all implemented natively without external dependencies. Drag-and-drop functionality, introduced experimentally in XEmacs 21, allows users to manipulate files, text selections, and buffers directly within the . A key aspect of XEmacs' graphical design is its device-independent graphics layer, built atop the Xt toolkit, which ensures consistent rendering of visual elements across varying X11 configurations and display hardware. This layer supports embedding XEmacs frames into external Xt-based applications, enhancing interoperability. Additionally, since the 1990s, XEmacs has pioneered innovations like in-buffer image display for formats such as XPM and , and sound support for playing audio files via protocols including and EsounD, predating similar capabilities in other variants. These GUI enhancements are further customizable through (Elisp), allowing users to script modifications to interface behaviors and appearances.

Package System and Modularity

The XEmacs package system was introduced in 1997 by Steve Baur to facilitate the installation, upgrading, and removal of Lisp libraries without requiring users to rebuild the editor from source. This system marked a significant advancement in modularity, allowing extensions to be managed as discrete, self-contained units that integrate seamlessly into XEmacs' architecture. By unbundling much of the Lisp code from the core distribution starting with XEmacs 21.1, the package system enabled developers to update functionalities independently, reducing the editor's base size and improving maintainability. Central to the system's design are its repositories, which include , alpha, and categories accessible via for incremental updates. Packages are organized into hierarchies such as xemacs-packages and mule-packages, with automatic setup of the load-path and autoloads upon , ensuring modular loading without . The Package-Rebuilder tool supports maintenance by rebuilding package manifests and handling binary deletions, while integration with Easy-PKG enables automated fetching and of add-ons directly within the interface. Built-in further enhances reliability, as the system verifies and retrieves prerequisites before . Compared to early GNU Emacs distributions, which lacked a comparable built-in until the of ELPA in 2009 and faced to such features as late as , XEmacs' package system offered superior ease of use and distribution of extensions from the outset. This approach minimized common configuration issues and empowered a broader contributor base through dispersed commit authority. A graphical for browsing and selecting packages provides users with an intuitive way to explore available add-ons.

Customization and Extensibility

XEmacs provides extensive customization through Emacs Lisp (Elisp), its primary extension language, which allows users to modify nearly every aspect of the editor's behavior and appearance. Elisp code can be written to define new commands, alter existing ones, and integrate advanced features, with XEmacs introducing specific primitives to enhance (GUI) elements such as toolbars, menubars, and faces for text attributes like fonts and colors. For , primitives like those in the sound-alist variable enable custom audible feedback, such as playing specific sounds for events on supported hardware. Users achieve site-wide or personal customizations by editing initialization files, typically ~/.emacs or ~/.xemacs/init.el, which load Elisp code upon startup to set variables, bind keys, and enable modes. of modules supports efficient incorporation of terminal-specific libraries or extensions without restarting the editor, a feature refined in XEmacs 21.4 to include loadable compiled modules for performance. Recent beta releases since have added features like TLS support for secure connections, further enhancing extensibility. This system facilitates seamless integration of user scripts for tasks like automated editing or workflow automation. Customization extends to themes via face definitions, where functions such as set-face-background, set-face-foreground, and set-face-font allow per-frame adjustments to colors, fonts (including Xft for anti-aliased rendering), and styles, supporting diverse visual preferences. Keybindings can be remapped globally with global-set-key or locally via define-key on keymaps, which in XEmacs are treated as first-class opaque objects for more robust handling. The editor includes numerous major and minor modes tailored to domains like programming (e.g., C++ mode with ), writing (e.g., with auto-fill), and more, each customizable through hooks and variables to suit user needs. Historically, XEmacs advanced extensibility over early by introducing extents—a for attaching properties to text that improves support for macros and complex editing operations—and enhanced introspection tools like the customize for interactively browsing and modifying variables with C-h v (describe-variable). These additions, pioneered in XEmacs versions 20 and 21, provided earlier access to widgets (e.g., native progress bars) and a more modular Elisp environment, influencing later developments in the ecosystem.

Development and Maintenance

Development Practices

XEmacs follows an open-source development model under the , utilizing systems that evolved from CVS in the 1990s to as a distributed system since around 2009. Early repositories were hosted via CVS on platforms like cvs.alioth..org for read-only access and commit access for qualified contributors, with a transition to repositories on hg..org, then Bitbucket.org, and after Bitbucket's 2020 discontinuation of support, to Heptapod (foss.heptapod.net) to support more collaborative distributed workflows. This shift facilitated easier branching and merging among volunteer developers, aligning with the project's emphasis on accessibility for open-source contributions. Community governance in XEmacs relies on decentralized coordination through mailing lists and beta release cycles, prioritizing volunteer-driven input over centralized authority. Key lists include xemacs-beta for discussing development updates and testing pre-release versions, and xemacs-patches for submitting and reviewing code changes, where contributors are encouraged to use tools like the patcher utility from the xemacs-devel package. Issues are managed through these lists and the integrated issue tracker in the Heptapod repository. This model fosters broad participation, with decisions emerging from community consensus on patches and features. Volunteers, regardless of experience level, contribute by identifying bugs, providing fixes, or enhancing packages, often through initiatives like Google Summer of Code. Development practices emphasize modular coding to enhance and potential , particularly in attempts to merge innovations with . The codebase separates core C components from libraries, enabling independent package development and updates via an integrated system that includes easy file system (EFS) support for remote fetching. This supports hourly automated builds and smoketests for packages, reducing risks and aiding efforts to share despite historical challenges in . Such approaches stem from XEmacs's philosophical divergence from 's more centralized, politically oriented governance under the . Key developers have played pivotal roles in advancing XEmacs, with Ben Wing contributing significantly to the display engine during the 2000s through retooling efforts and patches that improved rendering and support. Wing's work, including merges of data representations and ongoing refinements, enhanced the engine's efficiency for complex graphical interfaces and international text handling.

Release History and Current Status

The development of XEmacs began with the 19 series in the early , spanning releases from version 19.0 in 1992 to 19.15 in March 1997, during which it evolved from Lucid Emacs and introduced foundational enhancements like preliminary support and scrollbars. Subsequent iterations included the 20 series, starting with 20.0 in February 1997 and culminating in the stable 20.4 in February 1998, which integrated full multilingual support and separated core functionality from modular packages. The 21 series followed, with 21.4.0 released in 2001 as a stable branch focused on refinements to the package system and stability, receiving patches through 21.4.22 "Instant Classic" in January 2009. Development in the 21.5 beta series progressed more slowly, with 21.5.35 "" released in May 2023, incorporating support for GTK3 rendering, TLS encryption, and native 64-bit Windows builds to improve compatibility with contemporary systems. This was followed by 21.5.36 "leeks" in June 2025, continuing the beta line with incremental updates. Post-2010, XEmacs maintenance has been sporadic, emphasizing bug fixes, security patches, and compatibility enhancements such as an internal Unicode format for better text handling. As of November 2025, XEmacs is actively maintained by volunteers, with Vin Shelton overseeing the stable 21.4 branch receiving critical fixes, while the beta 21.5 branch sees ongoing commits (latest on November 17, 2025) toward the planned 22.0 release focusing on multilingual enhancements. There is no full-time team, but pre-built binaries are provided for modern operating systems including , macOS, and Windows, though the stable series receives only critical fixes while beta work plans toward a potential 22.0 release.

Derivatives

SXEmacs Fork

SXEmacs emerged as a of XEmacs 21.4.16 in late , led by Steve Youngs. The project aimed to deliver a cleaner codebase by systematically removing legacy hacks and redundancies accumulated in XEmacs, while emphasizing better modularity through restructured source hierarchies and separated build processes. These efforts focused on long-term maintainability, enabling easier integration of new features without compromising the core environment's integrity. Development progressed with the initial public release, SXEmacs 22.1.6, in December 2006, marking a shift to a dedicated 22.x series distinct from XEmacs's 21.x line. Subsequent milestones included the adoption of GPLv3 in November 2007 for stricter license compliance and ongoing enhancements for modern Emacs Lisp (Elisp) compatibility, such as a Foreign Function Interface (FFI) added in 2005 to directly interface with C libraries. Releases continued into the 2020s, with version 22.1.17 in September 2020 incorporating updates like improved multimedia handling and XDG compliance, ensuring sustained relevance in contemporary environments. Development has continued with bleeding-edge updates beyond 2020.

Other Related Projects

XEmacs has inspired several minor ports and derivatives aimed at expanding its reach beyond traditional Unix environments. Early efforts included the Win-Emacs project, derived directly from XEmacs 19.6, which provided a native Windows application with features such as multiple windows and , later integrated into the main XEmacs codebase by developer Ben Wing. Similarly, ports to Apple Macintosh systems were maintained post-2000, including adaptations of XEmacs 19.14 for and XEmacs 21.5.9 for Mac OS X using the Carbon framework, led by contributor Pitts Jarvis (who has since passed away). These non-Unix ports ensured continued accessibility for users on desktop operating systems, with binary distributions available through official mirrors into the . In the realm of embedded systems, XEmacs' emphasis on modularity influenced lightweight derivatives of Emacs-like editors, such as variants of MicroEmacs. MicroEmacs itself, originating in 1985 and evolved through contributions like those from Daniel M. Lawrence, inspired projects such as Jasspa MicroEmacs and NanoEmacs, which support low-resource platforms including DOS and Windows, and Z80EMacs, adapted for the constrained 64KB address space of CP/M systems in 1992 using overlays for efficient file handling up to 30KB. Another example is Freyja, a RAM-optimized derivative targeting palmtops and laptops with limited memory. Among legacy projects, multiple attempts to reconcile XEmacs with through mergers occurred in the early , following the 1997 split. At least six to seven major initiatives, initiated primarily by the XEmacs team, involved extensive discussions but ultimately failed due to irreconcilable differences in development philosophies, licensing concerns, and architectural divergences. These efforts highlighted ongoing community interest in unification but reinforced the separate trajectories of the projects.