Hubbry Logo
DilloDilloMain
Open search
Dillo
Community hub
Dillo
logo
8 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Contribute something
Dillo
Dillo
Dillo
View on Wikipedia
from Wikipedia
Dillo
Original authorJorge Arellano Cid
DeveloperRodrigo Arias Mallo
Initial releaseDecember 1999; 25 years ago (1999-12)
Stable release
3.2.0[1] Edit this on Wikidata / 18 January 2025; 10 months ago (18 January 2025)
Repository
Written inC and C++
Operating systemLinux, BSD, macOS, FreeDOS
Available inEnglish
TypeWeb browser
LicenseGPL-3.0-or-later
Websitehttps://dillo-browser.org/

Dillo is a minimalistic web browser particularly intended for older or slower computers and embedded systems.[2] It supports only plain HTML/XHTML (with CSS rendering) and images over HTTP and HTTPS; scripting is ignored entirely.[2][3] Current versions of Dillo can run on Linux, BSD, macOS, IRIX[4] and Cygwin.[5] Due to its small size, it is a popular choice for light-weight Linux distributions. Dillo is free software, released under the GNU GPL-3.0-or-later.[6]

Chilean software engineer Jorge Arellano Cid conceived the Dillo project in late 1999,[7] publishing the first version of Dillo in December of that year.[8] His primary goal in creating Dillo was to democratize access to information. Arellano Cid believed that no one should have to buy a new computer or pay for broadband in order to enjoy the World Wide Web.[9] To this end, he designed Dillo to be small, fast, and efficient, capable of performing well even on an Intel 80486 CPU with a dial-up Internet access.[2][10]

Development

[edit]

Dillo was originally written in the C programming language with the GTK+ GUI toolkit. The first versions were based on an earlier browser called Armadillo, hence the name.[11]

Dillo is funded by private donations;[12] efforts to obtain public grants and corporate sponsors have been unsuccessful.[13] Lack of funding led to a slowdown in development in 2006, and a complete stop in 2007.[6][14] The project restarted again in 2008 and two months later received a €115 donation from DistroWatch.[6][15]

Dillo 2 was written with both C and C++ components and the Fast Light Toolkit (FLTK),[8] and was released on October 14, 2008.[6] Text antialiasing, support for character sets other than Latin-1, HTTP compression capability, and improved page rendering were all added.[8] The move to FLTK from GTK+ also removed many of the project's dependencies and reduced Dillo's memory footprint by 50%.[6]

In 2011, Dillo 3.x was released, now using FLTK 1.3. According to the changelog, this change was partly driven by the absence of an official FLTK 2 release, which had previously prevented Dillo 2 from being included in lightweight distributions where it would have otherwise been suitable.

Development stalled in 2016 due to the death of the main developer of the rendering engine, Sebastian Geerken. Arellano Cid made his last post to the development mailing list in 2019.[16][17]

The original[18] domain had expired in June 2022.[19] Developers had lost access to it and a Wordpress zombie lookalike is operating without their oversight ever since.

Dillo 3.1.x was released in 2024, after development was restarted in December 2023 by Rodrigo Arias Mallo.[20]

Features

[edit]

Features of Dillo include bookmarks, tabbed browsing, and support for JPEG, PNG (including alpha transparency[21]), GIF[22] and SVG images.[23] Partial support for CSS was introduced in release 2.1. Settings such as the default fonts, background color, downloads folder, and home page are customizable through configuration files.[24][25] Cookies are supported but disabled by default due to privacy concerns.[26] While most web browsers retain the web cache and history after the program is closed, Dillo automatically clears them to improve both privacy and performance.[27]

Dillo running on a i486 laptop
Dillo's bug meter reports errors Dillo encountered in the web page being viewed

A developer tool called the "bug meter" is provided in the lower-right corner. When clicked, it displays information about validation problems, such as unclosed tags, that Dillo found in the web page.[28] Unlike most browsers, Dillo does not have a quirks mode to improve compatibility with web pages that use invalid HTML. Instead, Dillo processes all web pages according to the published web standards.[29]

In 2003, two Linux enthusiasts successfully ran Dillo on an Intel 486 processor and demonstrated that even with such meager hardware, Dillo could render Home - BBC News in 10–15 seconds.[30] Furthermore, Dillo can run on a variety of software platforms, including Linux, BSD, Solaris, macOS, MS-DOS compatible operating systems,[31] and some handheld devices.[5] However, Dillo's developers have made little effort to make the browser work on Microsoft Windows. Arellano Cid stated that Windows goes against Dillo's goal of democratization by artificially increasing hardware requirements and software costs.[32] Nevertheless, Dillo has been reported to work on Windows via Cygwin.[33]

Dillo does not support JavaScript, Java, Flash, right-to-left text, or complex text layout.[22][34] Support for frames is also very limited; Dillo presents a link to each frame to allow the user to view them one at a time.[35]

Forks

[edit]

Dillo-Win32 was a project to port Dillo to Windows which is now defunct.[36] D+ browser or Dplus continues where Dillo-Win32 left off, forked from the final Dillo-Win32 release (3.0p9), it does not attempt to maintain upstream compatibility with Dillo. The most recent version is 0.5b (Oct 15, 2013). [37]

DilloNG is a fork hosted on GitHub which moved the code from Mercurial while adding new features like a speed dial main page, support for opening videos in an external video player[38] and merged some previously published fixes. It was last updated in 2021.[39]

A fork called Dillo-browser[40] appeared in 2019 forked from the then-current version of DilloNG. It stalled until 2023 when its development resumed and is ongoing as of 2024.

Dillo+ (Dillo-Plus) started in 2023 based on Dillo 3.0.5 source code found in the OpenBSD 6.8 package.[41] It had applied numerous patches from DilloNG and added support for rendering Gopher, Gemini and markdown pages, reader mode and extended CSS support.[42] A new Python scripting system was introduced with modules for rendering RSS, EPUB, public Telegram channel logs and zip file contents.[43] It is still maintained as of 2024.[44]

Reception

[edit]

Reviews of Dillo have praised its extraordinary speed, but noted that this speed comes at a price.[22][45][46] The most visible cost is Dillo's inability to display complex web pages as they were meant to be. A 2008 review by Linux.com commented that Dillo's user interface may be "intimidating" for new users, and pointed out the scarcity of plug-ins for Dillo.[24] In all, Dillo's global usage share is less than one hundredth of one percent.[47]

Dillo is, however, the browser of choice in several space-conscious Linux distributions, such as Damn Small Linux,[48] Feather Linux,[49] VectorLinux,[50] antiX[45] and Mustang Linux.[45]

See also

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Dillo

View on Grokipedia
from Grokipedia

Dillo is a minimalist, open-source graphical web browser renowned for its exceptional speed and minimal resource footprint, making it ideal for resource-constrained environments such as older computers and embedded systems.
Written primarily in C and C++ using the FLTK toolkit for its interface, Dillo eschews heavy dependencies like JavaScript engines to prioritize performance and security, rendering pages without executing scripts that could pose privacy or exploit risks.
Originally initiated around 1999 by developer Antonio Larrosa, the project has endured for over 25 years through community efforts, including a recent revival that introduced enhancements like WebP image support and SVG rendering for mathematical formulas in version 3.2 released in early 2025.
While lacking compatibility with modern dynamic web technologies, Dillo excels in displaying static content efficiently, supports protocols beyond HTTP such as Gopher and Gemini, and maintains a focus on personal privacy by avoiding data-tracking features common in mainstream browsers.

History

Origins and Early Development

Dillo was initiated in late 1999 when a group of developers, led by Chilean software engineer Jorge Arellano Cid, forked the code from the project, originally developed by Raph Levien as a lightweight browser derived from Gzilla. Arellano Cid, a recent graduate of the Universidad Técnica Federico Santa María in , sought to build a fast, resource-efficient graphical capable of running on older hardware, addressing the limitations of contemporary browsers that demanded high-end systems. The initial focus emphasized minimalism, with the browser written primarily in C and dependent on the GTK+ toolkit for its user interface. The first releases of Dillo occurred in December 1999, marking the project's public debut with early alpha versions built on 1.0. These versions prioritized core browsing functionality, such as rendering and basic navigation, while maintaining a small binary size under 230 KB to facilitate deployment on embedded systems and low-powered devices. Development proceeded rapidly, with the project adopting the GNU General Public License (GPL) in March 2000 to encourage open collaboration. By mid-2002, after over two years of iterative improvements, Dillo had matured sufficiently to be positioned as an embeddable browser component, demonstrating stability for integration into larger applications. Early enhancements included refinements to the custom rendering engine for better compliance and performance on constrained hardware, alongside initial support for features like bookmarks and inline images. Arellano Cid led the core team, contributing to parsing and widget layers, while the project attracted collaborators interested in alternative lightweight toolkits. A significant milestone came in October 2004 with version 0.8.3, which introduced support via an update to the library, expanding secure browsing capabilities without bloating the footprint. These developments solidified Dillo's niche as a viable option for users prioritizing efficiency over full modern web standards compliance.

Mid-Period Expansion and Stagnation

Following the initial GTK-based development in the early , Dillo experienced a phase of technical expansion centered on toolkit migration and core functionality improvements. In February 2005, primary developer Jorge Arellano Cid and contributor Sebastian Rogal presented Dillo at , highlighting its lightweight design and potential for embedded systems. By April 2005, progress on porting Dillo to 2 was underway, aiming for better performance and cross-platform compatibility over the aging GTK1 backend. This effort culminated in April 2006 with the final GTK1 release, version 0.8.6, which included minor bug fixes and stability enhancements before the full transition. The FLTK2 port marked a key expansion milestone, but development faced early stagnation from mid-2006 to 2008, attributed to insufficient funding and maintainer bandwidth constraints, resulting in no official releases during this interval. An alpha version of the FLTK2 port was announced in September 2007, but substantive progress halted until October 2008, when Dillo 2.0.0 launched with the new backend, introducing tabbed browsing—a significant usability upgrade for multi-page navigation while maintaining the browser's minimal footprint under 10 MB. Subsequent releases in this period, such as version 2.2.1 in 2011, added incremental features like improved form handling and bug resolutions, though activity slowed after July 2009 when Cid announced reduced involvement due to personal commitments including fatherhood. A secondary expansion occurred with the shift to FLTK 1.3 starting in June 2011, coinciding with that toolkit's stable release; Dillo 3.0.0 followed shortly thereafter, enabling better widget rendering and support. Further advancements included a new hyphenation algorithm in version 3.0.3 (April 2013) for enhanced text layout and the final pre-stagnation release, 3.0.5, in June 2015, which incorporated security patches and rendering optimizations. These updates expanded Dillo's viability for low-resource environments, with successful builds on platforms like and embedded distributions. Stagnation intensified post- amid maintainer attrition; the October 2016 death of Sebastian Rogal, a key contributor, effectively halted momentum, followed by Cid's last project communication in 2019. No releases occurred from 2015 to 2023—a nine-year gap—during which the saw minimal commits, compatibility with modern web standards eroded, and forks like DilloNG emerged but also stalled without sustaining development. This period underscored Dillo's reliance on a small volunteer , vulnerable to life events and the growing complexity of web technologies outpacing its minimalist architecture.

Recent Revival and Milestones

Following a period of limited activity after the 3.0.5 release in 2015, Dillo underwent a revival driven by community developers who resumed maintenance via the project's repository, addressing long-standing bugs and incorporating previously unmerged changes from 2015–2017. This resurgence included the relocation of official resources to GitHub Pages after the original dillo.org domain expired in 2022 and was repurposed by unrelated parties. By 2024, the project had stabilized under new stewardship, emphasizing its lightweight design for modern embedded systems and low-resource environments while preserving core principles of minimalism and speed. Key milestones in this revival include the release of version 3.1.0 on May 4, 2024, which integrated fixes for rendering issues, improved CSS handling, and enhanced stability accumulated over prior years. This was followed by a minor update, 3.1.1, on June 8, 2024, focusing on bug resolutions and minor refinements. The effort culminated in version 3.2.0, released on January 18, 2025, coinciding with the browser's 25th anniversary in December 2024; this update added support for images, SVG rendering for mathematical formulas, and further optimizations for contemporary lightweight use cases. The revival gained public visibility through a February 2025 presentation at titled "Resurrecting the minimalistic Dillo ," where developers demonstrated the engine's performance on resource-constrained hardware and outlined ongoing work to maintain compatibility with basic web standards without bloating the footprint. These developments underscore Dillo's persistence as an open-source alternative prioritizing efficiency over feature parity with resource-intensive browsers.

Technical Foundation

Rendering Engine and Parsing

Dillo utilizes a custom rendering engine, the Dillo Rendering Engine (DRC), implemented in C and C++ for optimized speed and minimal resource overhead. Unlike engines such as Blink, Gecko, or WebKit, the DRC avoids bloated dependencies, enabling low memory usage and fast rendering of pages, including larger ones, on constrained hardware. The engine supports real-time rendering, incrementally processing and displaying content as it loads, integrated with the FLTK GUI library for output while retaining independent layout and painting logic. Recent updates have enhanced image buffering, caching, and widget sizing to improve performance and handle floating elements more effectively. Dillo's HTML parsing employs a proprietary parser adhering to a subset of HTML 4.01, extended with select HTML5 features like , , and placeholder attributes for form elements. During parsing, it identifies markup errors or non-compliance, reporting them through a bug meter that specifies line numbers for correction, promoting standards adherence. CSS parsing covers portions of CSS 2.1 and limited CSS 3 elements, including properties for display modes, text transformation, and background images, but excludes complex selectors and scripting-driven styles due to the lack of JavaScript support. This static approach ensures predictable rendering but restricts dynamic web features.

User Interface Toolkit

Dillo utilizes the Fast Light Toolkit (), a cross-platform C++ graphical user interface library, as its primary toolkit for constructing the browser's interface elements such as windows, toolbars, menus, and buttons. FLTK was selected for its emphasis on speed, minimal resource consumption, and portability across systems, Windows, and other platforms, aligning with Dillo's design philosophy of low overhead and efficiency. Unlike its early versions, which relied on the GTK+ toolkit for graphical components, Dillo transitioned to starting with later development iterations to reduce dependencies and enhance cross-platform compatibility; this shift enabled static linking of into the binary by default, minimizing runtime library requirements and contributing to a smaller overall footprint. The integration involves providing the foundational widgets and event handling, while Dillo's custom Dw (Dillo Widget) system—implemented with a -specific platform backend—handles the rendering for web content, bridging UI controls with the browser's layout and drawing primitives. This combination yields a responsive interface with low memory usage; for instance, Dillo's static linkage avoids overhead, and optimizations in versions like 1.3.x have been incorporated to fix platform-specific issues such as behavior and widget styling. 's lightweight nature supports Dillo's performance goals, enabling quick startup and interaction even on resource-constrained systems, though it limits adoption of advanced theming or native desktop integration found in heavier toolkits like Qt or . Developers can extend UI behaviors via 's widget subclassing, but Dillo prioritizes simplicity, with core components like the location bar and navigation buttons leveraging standard controls for mouse-driven operation.

Build and Platform Support

Dillo is compiled from source using the GNU autotools build system. The latest stable release, version 3.2.0 as of 2024, is distributed as a tarball or via Git clone from the official repository. Building requires FLTK 1.3 as the primary GUI toolkit dependency, along with image processing libraries such as libpng, libjpeg, libwebp, and libbrotli for optional format support; zlib is also needed. Optional TLS encryption relies on OpenSSL 1.1/3, LibreSSL, or mbedTLS 2/3. On Debian-based systems, relevant development packages include gcc, g++, autoconf, automake, zlib1g-dev, libfltk1.3-dev, libssl-dev (or equivalent), libpng-dev, libjpeg-dev, libwebp-dev, and libbrotli-dev. The standard build process from a release tarball entails extracting the archive (e.g., tar jxvf dillo-3.2.0.tar.bz2), creating a build directory, running ./configure --prefix=/usr/local (with --disable-tls to omit encryption if desired), followed by make and sudo make install. When building from Git, ./autogen.sh generates the configure script beforehand. Post-installation, a hyphenation database for text reflow can be set up via the dillo-install-hyphenation script. Adjustments for BSD, Solaris, macOS, or Windows (via Cygwin) involve platform-specific configure flags or toolchain setups, as detailed in the installation documentation. Dillo exhibits broad platform compatibility, with confirmed builds on Unix-like systems including GNU/Linux across architectures such as x86, amd64, ARM (e.g., Cortex-A8), and MIPS64EL; BSD variants like FreeBSD, OpenBSD, NetBSD (including NetBSD/VAX), and DragonFlyBSD; Solaris on SPARC and UltraSPARC; IRIX 6.5.27f; and macOS (including GNU Darwin on PowerPC and x86). Windows support is available through Cygwin, enabling graphical operation under POSIX emulation. Historical versions have run on MS-DOS-compatible systems, Atari 68k (via MiNT), handhelds like iPAQ and Psion 5MX, and embedded platforms such as StrongARM CPUs, Simputer, and Sony PlayStation 2 Linux. Earlier Dillo 1.x iterations extended to DEC Alpha, PowerPC, SPARC, Tru64 UNIX, HP-UX, AIX, QNX, and RISC OS, though modern releases prioritize lightweight Unix environments. Community reports confirm functionality on these setups following standard compilation, underscoring Dillo's emphasis on minimal dependencies for resource-constrained hardware.

Core Features

Browsing and Navigation Capabilities

Dillo supports session-based navigation history through dedicated Back and Forward buttons, which traverse previously visited pages in the current tab upon left-click. Middle-clicking these buttons opens the target page in a new tab, while right-clicking displays a menu listing stack entries for selection. Keyboard accelerators include the key (,) for back and the period key (.) for forward. The , or location bar, serves as the primary entry point for direct navigation, displaying the current page's address and accepting typed or pasted inputs. A red "X" clears the bar on left-click, and middle-clicking it pastes the system clipboard's if available. Users select the bar's contents with Ctrl+L for quick editing. Integrated search is invoked via a or Ctrl+S, routing queries to a user-configurable engine defined in the dillorc file's search_url parameter. Tabbed browsing enables multi-page management within one window, introduced in version 2.0. Links open in new tabs via middle mouse button or Ctrl+left-click, with blank tabs created through Ctrl+T or the . Tabs close via the "X" button or right-click on the tab label, and switching occurs with Alt+number (e.g., Alt+1 for the first tab). Configuration options in dillorc include focus_new_tab=YES for automatic activation of new tabs and middle_click_opens_new_tab=NO to favor new windows instead. Bookmarks facilitate persistent access to sites, saved by right-clicking a page and selecting "Bookmark this page" from the context . The manager opens via the Bookmarks button or Ctrl+B, displaying an editable list stored in ~/.dillo/bm.txt and accessible internally at dpi:/bm/. This file synchronizes across Dillo instances but lacks broader import/export beyond manual editing. Hyperlink traversal occurs via left-click on elements like underlined blue text (turning purple post-visit), with the cursor shifting to a hand over clickable areas. These actions automatically populate the navigation history stack. Dillo omits global or persistent history logging beyond the per-session stack, prioritizing minimal resource use over exhaustive tracking.

Media and Format Support

Dillo renders static images in , , , (with initial support added in version 3.2.0 for simple graphics and mathematical formulas), and formats. These capabilities enable basic visual content display without reliance on scripting or dynamic elements. The browser also handles documents directly, converting them for on-screen viewing. Embedded such as video or audio streams lacks native playback support, aligning with Dillo's minimalist design that prioritizes over comprehensive media handling. Users must invoke external applications for such content, as the core engine does not integrate decoding or rendering for formats like MP4, , or similar. This limitation stems from the absence of plugin architectures or libraries in the standard build, though experimental variants have explored additions like video playback via configuration tweaks. Format compatibility extends to a subset of web standards, including HTTP/HTTPS-delivered images and basic file types, but excludes vector formats beyond basic or proprietary codecs. Configuration options allow ignoring specific image formats to optimize performance or bandwidth. Overall, Dillo's media support emphasizes lightweight, standards-compliant static assets over interactive or , reflecting its focus on speed and low footprint.

Extensions and Protocols

Dillo provides native support for the HTTP and protocols, enabling the loading of remote web content with optional SSL/TLS encryption via libraries such as or mbedTLS. It also handles FTP for file transfers, typically leveraging external tools like for downloads, and supports local file access through the . Additional protocols, including , Gemini, IPFS, IPNS, and Spartan, are supported through the Dillo Plugin Interface (DPI), which allows extensions in any programming language via standard input/output or Unix domain sockets. Plugins function as filters or servers: filter plugins process single requests (e.g., translating Gemini content to ), while server plugins handle multiple interactions over sockets. Configuration occurs in the user's ~/.dillo/dpidrc file, mapping protocol schemes to plugin executables, such as proto.gemini = ~/.dillo/dpi/gemini/gemini.filter.dpi for the Gemini plugin implemented in Bash. The DPI emphasizes modularity by offloading optional features from the core codebase, including protocol handlers like FTP browsing with progress feedback or built-in services such as bookmark management via dpi:/bm/. Examples include the C-based Gopher plugin for menu navigation and the Go-based IPFS plugin for decentralized content retrieval. This approach maintains Dillo's lightweight footprint but limits extensibility to protocol and format translation rather than dynamic scripting or user-installed add-ons typical of larger browsers. Plugins are community-contributed and integrated via pull requests to the project's repository.

Limitations and Design Trade-offs

Unsupported Modern Technologies

Dillo lacks support for (ECMAScript), a core technology for dynamic , interactive elements, and client-side scripting, which is present in nearly all modern browsers. This omission is deliberate, prioritizing security and performance over functionality, as JavaScript execution introduces risks like and resource-intensive operations. Without JavaScript, Dillo cannot render sites reliant on frameworks such as React or Angular, or execute scripts for form validation, AJAX requests, or real-time updates, resulting in static or broken displays on JavaScript-dependent pages. The browser supports only a subset of elements and attributes, excluding advanced features like <canvas>, <video>, <audio>, and Web APIs for multimedia playback or graphics rendering. While basic HTML4.01 and some transitional HTML5 tags are handled via Dillo's custom rendering engine, semantic elements like <article> or <nav> may render as plain text without structural enhancements, and forms lack progressive enhancement. This partial conformance stems from the engine's focus on core parsing rather than full standards compliance, avoiding the complexity of stateful rendering models used in engines like Blink or . CSS3 implementation is incomplete, covering CSS 2.1 basics like selectors, box model, and positioning but omitting modules for animations, transitions, flexbox, grid layouts, beyond simple breakpoints, and advanced pseudo-elements. As a result, responsive designs, , and modern fail to apply, leading to uniform, non-adaptive layouts unsuitable for mobile or high-resolution displays. Dillo also eschews support for , , and service workers, technologies enabling hardware-accelerated graphics, compiled code execution, and offline capabilities, respectively, further limiting compatibility with performance-oriented web applications. These exclusions align with Dillo's design philosophy of minimalism, evidenced by its avoidance of plugin architectures that could bridge gaps (e.g., no or extension APIs for injecting engines), ensuring low memory usage—typically under 10 MB for basic pages—but rendering approximately 70-80% of contemporary websites as partially or fully non-functional as of 2024 benchmarks in browser evaluations.

Resource Usage and Performance Realities

Dillo maintains an exceptionally low resource footprint, with its compiled binary typically under 250 KB in size, enabling rapid startup times of approximately 2 seconds on capable hardware. This minimalism stems from its custom rendering engine and avoidance of heavy dependencies, allowing operation on resource-constrained devices such as older Intel 486 processors or handheld PDAs like the iPAQ. Idle memory usage has been measured as low as 3.9 MB resident set size (RSS) in version 2.1 on 32-bit Ubuntu systems, roughly half that of earlier iterations like 0.8.6. When loading basic HTML4 pages, consumption rises to 10-20 MB, positioning it among the lowest for graphical browsers. Performance excels in rendering and networking for supported formats, with innovative concurrency models ensuring a responsive interface without blocking the user thread. On low-end systems, such as those with 4 MB RAM, Dillo operates viably for text-heavy or static sites, outperforming feature-rich browsers in speed and efficiency for compatible content. However, the absence of , advanced CSS, and support results in failures to load or render contemporary websites, effectively nullifying performance gains on dynamic web applications. In comparative contexts, Dillo's design prioritizes efficiency over completeness, yielding low CPU utilization during supported tasks but exposing trade-offs on modern hardware where unsupported elements force reliance on fallback or external tools. Recent evaluations, including 2025 discussions, highlight ongoing measurements of energy and memory efficiency, affirming its viability for embedded or legacy environments but underscoring limitations for general-purpose browsing.

Forks and Community Derivatives

Notable Forks

DilloNG represents an early effort to revive and test concepts from the original Dillo codebase, ported from its repository to for and experimentation. This fork preserves Dillo's lightweight footprint of approximately 10 MB and avoidance of , while introducing a speed dial homepage, extensive bookmark management without scripting dependencies, and configurable domain rules for blocking advertisements and trackers or enforcing . Media handling is delegated to external players rather than integrated playback. Maintained by developer w00fpack, it focuses on proof-of-concept enhancements rather than full production deployment. Dillo-Plus (also known as Dillo+) builds directly on the official Dillo source, incorporating fixes and merges from DilloNG to expand protocol support beyond standard HTTP and . Key additions include native handling of Gemini, , files, and a reader mode that strips extraneous styling for faster text-focused browsing. It features quick-search integration with engines like and via keyboard shortcuts, alongside DPI modules for browsing ZIP archives, man pages, and FTP directories. Targeted at systems including and BSD, this approximately 10 MB browser prioritizes performance on legacy hardware without introducing dependencies. Development is led by crossbowerbt, with ongoing refinements to multi-platform compatibility. Other derivatives, such as Mobilized Dillo, adapt the core engine for mobile environments like phones, emphasizing tabbed browsing via middle-click navigation and automatic tab focusing, though these remain niche personal modifications without widespread repository-based distribution. Less prominent forks like fredollinger's variant maintain the minimalistic but lack documented unique advancements beyond basic portability tweaks. These efforts highlight community-driven preservation amid the official project's intermittent activity, though none have achieved the scale of the revived mainline Dillo 3.1 release in May 2024.

Active Maintenance Efforts

Dillo's maintenance was revived in 2022 following the expiration of its original domain and loss of repositories, with a primary developer recovering old content and establishing a new organization at github.com/dillo-browser. This effort included migrating to for , hosting the project website at dillo-browser.github.io, and archiving materials on archive.org to ensure continuity. By December 2024, the lead maintainer reported ongoing personal commitment to the project, supplemented by emerging contributions from new developers submitting patches for bug fixes and enhancements. Key milestones in recent maintenance include the release of version 3.1.1 on June 8, 2024, which incorporated fixes and features accumulated since earlier development periods, followed by version 3.2.0 on January 18, 2025, marking the browser's 25th anniversary with additions such as image support and rendering for mathematical formulas. These updates addressed long-standing gaps, including improved compatibility with modern image formats and floating elements via OpenSSL integration in prior releases. Development focuses on preserving Dillo's lightweight architecture while incrementally enhancing functionality, with activity evidenced by commits and a custom bug tracker launched in September 2025 to streamline issue management beyond standard platforms. Community involvement remains modest but growing, with forks like dillo-plus extending core capabilities (e.g., HTTPS and Gemini protocol support) and occasional integrations in lightweight Linux distributions such as antiX. The project's emphasis on minimal resource use drives maintenance priorities, prioritizing security patches and privacy features over expansive feature creep, as articulated in developer talks at events like FOSDEM 2025. As of October 2025, Dillo sustains active development through this volunteer-led model, contrasting prior dormancy from 2015 to 2022.

Reception and Legacy

Positive Assessments

Dillo's developers emphasize its superior rendering and networking speeds, enabled by a lightweight architecture and innovative concurrency model that ensures the remains responsive even during intensive operations. This efficiency stems from its core implementation , resulting in a binary size under 300 KB and minimal dependencies, allowing operation on legacy hardware such as 486 processors or systems with telephone-line connections. Independent reviews commend Dillo's low and rapid performance, positioning it as a viable option for resource-limited environments, including older PCs with 128 MB RAM or embedded devices like early models. For instance, testers have reported it outperforming alternatives like Midori in speed on constrained hardware, while consuming significantly fewer resources than or Chrome. Users and analysts praise its uncluttered interface and lightning-fast loading for basic tasks, free from the bloat associated with feature-heavy modern browsers, making it suitable for straightforward web access without compromising on essentials like tabbed and support. Software evaluations highlight its value for ultra-minimalist setups, recommending it for scenarios prioritizing speed and simplicity over advanced scripting.

Criticisms and Comparative Analysis

Dillo faces criticism for its absence of support, a core limitation that prevents rendering of dynamic content essential to the majority of modern websites, thereby restricting its practical utility beyond static pages. This omission, while enhancing and reducing complexity, results in frequent failures to load interactive elements, such as forms or menus, on sites like search engines or e-commerce platforms. Reviewers have highlighted that Dillo's partial CSS compliance and lack of features like frames further degrade rendering fidelity, often producing incomplete or visually distorted layouts on standards-nonconformant pages. Additionally, issues, including failure to auto-focus text input fields, complicate basic tasks like querying , underscoring Dillo's trade-offs in favor of over user convenience. Comparatively, Dillo outperforms text-only browsers like in graphical capabilities, supporting image display and rudimentary styling, yet it incurs a slight resource penalty due to its FLTK-based interface, making preferable for ultra-low-spec devices prioritizing raw efficiency over visuals. Against fellow lightweight graphical alternatives such as , Dillo maintains a smaller and quicker page loads—often under 10 MB RAM for simple sites—but cedes ground in web standards adherence, with offering superior HTML5 and CSS parsing for more reliable modern page depiction, albeit with marginally higher overhead. In contrast to heavyweight browsers like , Dillo's sub-50 MB typical usage enables operation on hardware as dated as 486 processors, where full-featured engines falter, but this efficiency comes at the cost of incompatibility with JavaScript-dependent ecosystems, rendering Dillo suitable primarily as a supplementary tool for quick, text-centric browsing rather than comprehensive web access.

References

  1. https://dillo-browser.github.io/
  2. https://github.com/dillo-browser/dillo
  3. https://dillo.org/
  4. https://dillo-browser.github.io/user_help.html
  5. https://dillo-browser.github.io/25-years/index.html
  6. https://9to5linux.com/dillo-3-2-open-source-web-browser-released-to-celebrate-25th-anniversary
  7. https://hackaday.com/2024/05/11/the-minimalistic-dillo-web-browser-is-back/
  8. https://news.ycombinator.com/item?id=27951086
  9. https://dillo-browser.github.io/old/jcid/index.html
  10. https://www.linuxjournal.com/article/5847
  11. https://the-dillo-web-browser.soft112.com/
  12. https://linuxdevices.org/introducing-dillo-a-lightweight-embeddable-browser-a/index.html
  13. https://www.osnews.com/story/139566/dillo-3-1-0-released-first-release-since-2015/
  14. https://github.com/dillo-browser/dillo/releases
  15. https://dillo-browser.github.io/dillo.org.html
  16. https://dillo-browser.github.io/release/3.1.0/
  17. https://dillo-browser.github.io/release/
  18. https://archive.fosdem.org/2025/schedule/event/fosdem-2025-4100-resurrecting-the-minimalistic-dillo-web-browser/
  19. https://hackaday.com/2025/01/19/dillo-turns-25-and-releases-a-new-version/
  20. https://linuxcommandlibrary.com/man/dillo
  21. https://dillo-browser.github.io/old/help/bug_meter.html
  22. https://www.fltk.org/
  23. https://dillo.org/developer.html
  24. https://dillo-browser.github.io/doxygen/dw-usage.html
  25. https://dillo-browser.github.io/doxygen/dw-overview.html
  26. https://dillo-browser.github.io/doxygen/classdw_1_1fltk_1_1ui_1_1FltkResource.html
  27. https://dillo.org/memory.html
  28. https://www.fltk.org/doc-1.1/common.html
  29. https://github.com/dillo-browser/dillo/blob/master/doc/install.md
  30. https://dillo.org/compatibility.html
  31. http://tuxarena.blogspot.com/2008/10/dillo-20-gets-tabbed-browsing.html
  32. https://dillo-browser.github.io/release/3.2.0/
  33. https://www.mankier.com/1/dillo
  34. https://dillo.org/dpi1.html
  35. https://github.com/dillo-browser/dillo-plugin-gemini
  36. https://news.ycombinator.com/item?id=38847613
  37. https://dillo.org/css.html
  38. https://dillo-browser.github.io/fosdem-2025/
  39. https://dillo-browser.github.io/old/funding/advantages.html
  40. https://www.quora.com/What-is-Dillo-Browser-worth-to-use-for
  41. https://www.reddit.com/r/browsers/comments/1k3oc04/browsers_which_use_the_least_amount_of_ram/
  42. https://www.phoronix.com/news/Dillo-3.1-Web-Browser
  43. https://github.com/w00fpack/dilloNG
  44. https://github.com/crossbowerbt/dillo-plus
  45. https://www.toomanyatoms.com/software/mobilized_dillo.html
  46. https://github.com/fredollinger/dillo
  47. https://www.theregister.com/2024/05/07/dillo_browser_v3_1/
  48. https://9to5linux.com/dillo-3-1-open-source-web-browser-released-after-9-year-hiatus
  49. https://dillo.org/funding/advantages.html
  50. https://dillo-browser.github.io/old/interview.html
  51. https://en.ubunlog.com/dillo-the-lightest-free-web-browser/
  52. https://askubuntu.com/questions/196339/what-are-the-available-browsers-for-128-mb-of-ram-pc
  53. https://www.linuxinsider.com/story/for-fast-light-web-browsing-dillos-no-dallier-73420.html
  54. https://hyperborea.org/reviews/software/dillo/
  55. https://www.softpedia.com/reviews/linux/Dillo-25310.shtml
  56. https://tuxarena.com/2014/03/overview-of-the-lightweight-dillo-browser/
  57. https://news.ycombinator.com/item?id=38848610
  58. https://politictech.wordpress.com/2021/01/27/pinephone-browsers-comparison-netsurf-falkon-dillo-firefox/
Add your contribution
Related Hubs
Contribute something
User Avatar
No comments yet.