Enlightenment Foundation Libraries
The Enlightenment Foundation Libraries (EFL) are a collection of open-source software libraries designed to facilitate the development of graphical user interfaces and applications, with a focus on efficiency for embedded systems, desktops, and other platforms.[1] Originating from the Enlightenment window manager project started in 1997, EFL underwent a significant rewrite in 2001 to support version 0.17 of the window manager, evolving into a modular toolkit for handling tasks like rendering, event processing, data management, and multimedia.[2] Licensed under a combination of LGPL and BSD licenses, EFL emphasizes low resource consumption, fitting into as little as 8 MB with minimal dependencies while supporting features such as internationalization, theming, and compatibility with display servers like X11, Wayland, and DRM.[2][3] Key components of EFL form a layered architecture, starting with foundational libraries like Eina for data structures and Ecore for core utilities including event loops, networking, and inter-process communication.[3] Graphics and rendering are managed by Evas, a state-aware canvas that optimizes drawing to reduce CPU and memory usage through techniques like glyph compression and anti-overdraw.[2] For user interface design, Edje provides a declarative layout engine enabling dynamic theming and separation of visual elements from application logic, while Elementary offers a set of ready-to-use widgets built atop these layers.[3] Additional libraries such as Eet handle data serialization and storage, and Emotion supports multimedia playback, making EFL versatile for diverse applications.[2] EFL powers a wide range of devices and software, including mobile platforms like Tizen, set-top boxes, medical devices, home automation systems, and the Enlightenment desktop environment itself, with version 1.28 released in January 2025 introducing API enhancements and stability improvements.[2][4] Its optimization for varied hardware—from low-power embedded controllers to high-end desktops—has made it a staple in Linux-based ecosystems, particularly through contributions from developers at Samsung and the broader open-source community.[2] The libraries continue to evolve, supporting modern standards like Vulkan for rendering and Lua scripting via Elua for runtime applications.[5]Overview
Purpose and Design Philosophy
The Enlightenment Foundation Libraries (EFL) serve as a suite of C-based libraries designed to facilitate efficient graphical user interface (GUI) development, encompassing functionalities for graphics rendering, event handling, data management, and UI theming. Originally developed as the foundational components for the Enlightenment window manager, EFL libraries are engineered to operate independently, enabling developers to integrate specific modules into standalone applications without dependency on the full window manager stack. This approach supports the creation of lightweight, high-performance software suitable for diverse environments, from desktops to resource-limited devices. As of March 2025, the latest stable release is version 1.28.1, incorporating ongoing optimizations for performance and compatibility.[2][4][6] Central to EFL's design philosophy is modularity, which allows individual libraries to be used in isolation or combined as needed, promoting flexibility and reducing overhead in application development. The libraries prioritize optimization for mobile and embedded systems, achieving a minimal footprint—such as fitting core components into 8 MB with few dependencies—while leveraging hardware acceleration through backends like OpenGL ES to minimize CPU, GPU, memory, and battery consumption. Portability is ensured via abstraction layers that support Unix-like operating systems, including X11, Wayland, framebuffer, and even non-Linux platforms like Windows and macOS, without sacrificing performance.[7][2][8] EFL embodies a clear separation of concerns, distinguishing rendering mechanisms—such as the canvas-based system in the Evas library—from declarative UI theming handled by Edje, which allows for dynamic layouts and visual customizations independent of the underlying rendering engine. This modular layering fosters portability and maintainability across hardware variations. A distinctive aspect of EFL's philosophy is its "everything is an object" paradigm, implemented through the Eo infrastructure, which treats UI elements as composable objects with shared functions and minimal inheritance, enabling efficient, state-aware management without excessive boilerplate code. For instance, Evas objects handle automatic updates and rendering, simplifying development for composable interfaces.[7][2][9]Licensing and Platforms
The Enlightenment Foundation Libraries (EFL) are licensed under a combination of the GNU Lesser General Public License version 2.1 (LGPL v2.1), the BSD 2-Clause license, and the GNU General Public License version 2 (GPL v2) for certain components and tools, enabling developers to integrate the libraries into proprietary applications via dynamic linking without mandating the release of the application's source code.[10] Certain components, such as the Evas canvas library, fall under the more permissive BSD 2-Clause license, while some tools and executable binaries are governed by the GNU General Public License (GPL v2). This mixed licensing approach, often referred to as dual-licensing in practice for flexibility, supports broad adoption in commercial projects by balancing open-source principles with proprietary compatibility.[10][11] Sponsorship from organizations including Samsung and ProFUSION has reinforced EFL's open-source model, funding development while preserving the ability for commercial entities to leverage the libraries without full source disclosure under LGPL terms.[12] EFL powers the Enlightenment window manager, demonstrating its licensing in a real-world desktop environment.[13] In terms of platforms, EFL targets Unix-like operating systems such as Linux and BSD variants, with core optimizations for resource-constrained environments like ARM-based mobile devices, desktops, and embedded systems including set-top boxes and game consoles.[14] It provides native support for these through backends like X11, Wayland, and framebuffer rendering. Partial portability to non-Unix platforms is achieved via wrappers; for instance, macOS compatibility is facilitated through Homebrew installations and source builds, while Windows support remains experimental, relying on MinGW or cross-compilation tools.[15][2]History
Origins and Early Development
The Enlightenment Foundation Libraries (EFL) emerged in the early 2000s from the development of Enlightenment DR17 (version 0.17), initiated by Carsten Haitzler, known as Rasterman, to provide robust support for compositing, rendering, and theming in the window manager.[16] This effort built upon the Enlightenment project's foundations, which began in 1997, but focused on creating reusable components to enhance graphical capabilities across platforms.[17] Early milestones included the development of foundational libraries for image handling, starting with Imlib2 in 1999 as a precursor to EFL for efficient image loading, scaling, and alpha blending.[17] In 2000, Evas was introduced as a stateful canvas library leveraging Imlib2 and supporting hardware acceleration via OpenGL, while Ecore provided abstractions for event loops and system integration.[16] The first cohesive EFL release was tied to Enlightenment 0.16 around 2003, integrating these early libraries into a unified framework during the ebits experimentation phase from 2001 to 2003.[16] A key event in the mid-2000s was the shift from a monolithic architecture to a modular structure, enabling the libraries' reuse in applications beyond the Enlightenment window manager itself.[18] This modularity was driven by the need for portability and efficiency, with a preview release of EFL announced in 2004 to support ongoing DR17 work.[18] Edje, introduced in 2004, exemplified this approach by handling theming and scripted behaviors through a declarative format.[16] The formal branding of the suite as Enlightenment Foundation Libraries solidified around 2008, aligning with intensified development for the Enlightenment 0.17 release.[16] Major refactoring occurred between 2008 and 2010, including the addition of Eina in 2008 for data structures and culminating in EFL 1.0 in January 2011, which established API and ABI stability.[16][19]Key Milestones and Releases
The Enlightenment Foundation Libraries (EFL) achieved a significant milestone with the release of version 1.0 in January 2011, which introduced stable APIs and optimizations tailored for mobile and embedded devices. This version solidified the core architecture, enabling reliable development of graphical applications and the Enlightenment window manager on resource-constrained platforms.[20][19] Subsequent releases built on this foundation, with EFL 1.7 in 2013 marking the maturity of the Elementary widget toolkit, providing a robust set of user interface components for desktop and mobile applications. This update enhanced widget stability and functionality, facilitating the stable rollout of Enlightenment 0.17.[20] In 2017, EFL 1.20 introduced a Vulkan rendering backend to Evas, the graphics library, improving performance on modern GPUs through low-overhead graphics API support and enabling better efficiency in compositing and rendering pipelines. This addition aligned with growing adoption of Vulkan in Linux ecosystems for high-performance graphics.[20][21] EFL 1.26, released in December 2021, emphasized security enhancements and performance improvements across core libraries, including better memory management in Eina and optimized event handling in Ecore to address vulnerabilities and reduce overhead in multi-threaded environments.[20] The most recent stable release, EFL 1.28.0 on January 11, 2025, incorporated API extensions for enhanced Wayland integration, such as improved surface handling and protocol compliance, alongside numerous bug fixes to ensure compatibility with contemporary compositors.[20] Throughout its evolution, EFL has followed structured deprecation cycles to modernize its codebase, notably phasing out X11-specific code in favor of Wayland compositing to support secure, direct-rendering sessions without legacy dependencies. Components like Embryo have seen a reduced role, with developers encouraged to migrate to more efficient alternatives like native C or JavaScript bindings for scripting needs.Core Libraries
Evas
Evas serves as the foundational 2D canvas library within the Enlightenment Foundation Libraries (EFL), providing a hardware-accelerated vector graphics engine for rendering shapes, images, text, and animations.[22] It abstracts low-level graphics operations across various display systems, enabling efficient drawing in applications and window managers. Designed for performance in resource-constrained environments, Evas optimizes rendering through techniques that minimize CPU and memory usage.[22] The library features an object-oriented API centered on theEvas_Object structure, which represents graphical primitives like rectangles, images, and text blocks. Developers can manipulate these objects using functions such as evas_object_rectangle_add() for creating filled or outlined shapes, evas_object_image_add() for loading and scaling raster images, and methods for positioning (evas_object_move()) and resizing (evas_object_resize()). Evas supports multiple backends, including OpenGL for hardware acceleration, a software rasterizer for portability, and framebuffer for direct console rendering, allowing seamless adaptation to different hardware targets.[22]
Key to its efficiency is the implementation of anti-aliased rendering for smooth edges on shapes and text, alongside clipping mechanisms that enable precise compositing of overlapping objects with alpha blending for transparency effects. This facilitates complex scene management without excessive computational overhead. Evas integrates closely with Edje, the declarative UI description library, to extend its capabilities for themed and animated graphical elements.[22] Version 1.0 of Evas was released as part of EFL 1.0 in January 2011, marking a stable milestone after years of development focused on embedded and desktop use cases.[19] Higher-level toolkits like Elementary build upon Evas for widget-based interfaces.[22]
Edje
Edje is a graphical design and layout library within the Enlightenment Foundation Libraries (EFL), serving as a theming engine that enables the creation of complex user interfaces through declarative descriptions rather than imperative C code.[23] It allows developers and designers to define visual elements, such as window borders, buttons, and scrollbars, with support for animations, state transitions, and dynamic behaviors, while packaging themes into compact .edj files that include shared image and font resources.[24] By separating UI layout and logic from application code, Edje facilitates artist-driven design, where themes can be modified independently without recompiling the software.[25] The core of Edje is its declarative UI description language, known as Edje Data Collections (EDC), a text-based format compiled into binary .edj files using the edje_cc tool.[24] EDC files specify layouts, animations, and states using structured syntax, allowing for the composition of interfaces composed of "parts"—which are instances of Evas objects like rectangles, images, or text blocks—and "programs," which are event-driven scripts that handle transitions, such as smooth animations or property changes over time.[23] External parameters in EDC enable dynamic theming by allowing runtime data injection, such as colors or sizes, via messages and signals passed from the application.[24] Edje employs a collection-based theming system, where multiple reusable layout groups (collections) can coexist in a single .edj file, promoting modularity and efficiency through shared resources.[23] This system supports theme inheritance, enabling collections to extend or override parts and programs from base themes using logical naming conventions, which reduces redundancy and eases customization.[24] Additionally, Edje integrates scripting hooks via the Embryo language for advanced interactivity and supports sound playback tied to program events, further enhancing its role in multimedia UI design.[24] Developed to enable artist-driven UI design, Edje evolved from the earlier Ebits tool and was conceived specifically for the Enlightenment 0.17 window manager project, with its first major use appearing in development builds around 2008.[25]Ecore
Ecore serves as the foundational event loop and abstraction library within the Enlightenment Foundation Libraries (EFL), providing a cross-platform mechanism to unify handling of file descriptors, timers, animations, and network events into a single, efficient main loop. This design allows applications to process events asynchronously without blocking, supporting multiplexing across various input sources such as sockets, pipes, and user inputs. By abstracting low-level system calls, Ecore enables developers to write portable code that operates seamlessly on Unix-like systems, reducing the need for platform-specific implementations.[26] Key features of Ecore include modular backends for display and audio systems, such as Ecore_X for X11 integration, Ecore_Wl for Wayland compositing, and support for PulseAudio via Ecore_Audio. The Ecore_Animator module facilitates smooth animations through timer-based interpolations, allowing precise control over frame rates and easing functions for visual transitions. Additionally, Ecore provides abstractions for inter-process communication (IPC) through Ecore_IPC, which handles message passing via Unix domain sockets, and pipe operations for local data exchange, simplifying synchronization between processes. Idle enter and exit callbacks further enhance efficiency by triggering functions when the system is idle, aiding in power management scenarios like screen blanking or CPU throttling.[27][26] Initial Wayland support was integrated into Ecore around 2012, enabling EFL applications to leverage the protocol for modern display server operations and significantly reducing the volume of platform-specific code required for rendering and input handling. This advancement built on EFL 1.0's stable foundation from 2011, marking a pivotal step toward broader compositing protocol compatibility. Ecore integrates briefly with Evas for event-driven rendering, feeding input and timer events directly into the canvas system to drive updates efficiently.[28][19]Eina
Eina serves as the foundational utility library within the Enlightenment Foundation Libraries (EFL), providing efficient implementations of common data structures and utilities to support other EFL components. It offers generic data types such as lists, hashes, arrays, red-black trees, and strings, all designed to minimize CPU usage while optimizing memory efficiency through features like memory pooling. These structures enable developers to handle complex data management tasks without relying on ad-hoc implementations scattered across EFL libraries, promoting consistency and performance across applications.[29][30] Key features of Eina include the Eina_Bool type, an unsigned char-based boolean that facilitates error-prone operations by serving as a return value for success or failure in functions, allowing compact bitfield usage and compatibility with EFL's low-level design. Performance is enhanced through extensive use of inline functions, reducing overhead in critical paths, while built-in logging via Eina_Log and profiling tools like Eina_Evlog enable debugging and optimization by tracking events and resource usage. Eina also introduces specialized concepts such as hash tables for key-value storage, which employ chaining for collision resolution to maintain efficiency under load, and string buffers that dynamically grow strings without frequent reallocations, thereby avoiding unnecessary memory operations.[31][32][19] Development of Eina began in 2008 as part of efforts to standardize data handling in EFL, culminating in its inclusion in the EFL 1.0 release in January 2011, where it replaced fragmented data structures in prior implementations. This integration marked a significant milestone, allowing seamless data serialization with libraries like EET while ensuring cross-platform compatibility on systems such as Linux, BSD, and Windows.[30][33]EET
EET is a data serialization library in the Enlightenment Foundation Libraries (EFL) that enables the storage and transmission of arbitrary data in a simple, compressed binary format optimized for structs, lists, and dictionaries based on Eina data types.[34] This format supports zlib compression, making EET files compact and suitable for efficient network transfer without additional archiving, while providing fast random-access reads for data written once and accessed multiple times. Version 1.0 of EET was released on April 24, 2008, as part of the EFL development efforts, with a primary design focus on handling theme files and configuration storage for the Enlightenment window manager.[35] Key features include optional encryption for secure data handling and big-endian encoding to ensure platform independence across different architectures.[34] It integrates with Ecore for streamlined file I/O operations, allowing developers to leverage EFL's event-driven model for asynchronous data persistence. At its core, EET uses EET_File handles—created via functions likeeet_open—to manage file operations, supporting reading and writing of serialized data through APIs such as eet_data_write and eet_data_read. A built-in directory table functions as an EET_Dictionary, indexing entries by name with details on offsets, sizes, and compression flags for quick retrieval.[34] This binary approach avoids the parsing overhead and larger file sizes typical of text formats like XML or JSON, prioritizing speed and minimal resource use in embedded and desktop applications.[34]