Dillo Web Browser

🌐 Overview

Name: Dillo

Type: Lightweight graphical web browser

Developer: Initially developed by Arno Puder, later maintained by the open-source community

Initial Release: 1999

Programming Language: C (using GTK+ for GUI)

License: GNU General Public License (GPL)

Platforms: Unix/Linux, Windows, BSD, and other POSIX systems

Philosophy: Focus on speed, minimal memory usage, simplicity, and security, sacrificing some modern web features (like JavaScript) to maintain performance.

🕰️ Full Historical Timeline

Year—>Event / Milestone
1999—>Dillo 0.1 released by Arno Puder. Designed as a fast, minimal browser for Unix/Linux systems. Supported basic HTML and images.
2000—>Version 0.3 released. Added table support, bookmarks, and improved navigation. Popular among Linux users with older hardware.
2001—>Version 0.4 released. Introduced frames support, printing capabilities, and better image handling.
2002—>Dillo 0.5 series. Added basic SSL/HTTPS support, improving security for online browsing.
2003–2005—>Version 0.6 series. Improved HTML 4.0 rendering and UTF-8/Unicode support. Became a standard lightweight browser for minimal Linux distributions like Damn Small Linux.
2006—>Dillo 0.7 series introduced. Enhancements included improved CSS rendering, smoother scrolling, and minor bug fixes. Still no JavaScript support to maintain speed and security.
2010—>Dillo 0.8 series released. Focus on stability and memory optimization, as modern websites became more resource-intensive. Added minor usability improvements like better bookmarks management.
2012–2015—>Community-driven bug fixes and minor features. Maintained graphical interface via GTK+, lightweight footprint (~1–2 MB), and fast startup.
2016–2020—>Dillo continued being maintained in Linux distributions (Tiny Core, Puppy Linux, Damn Small Linux). Minor updates ensured compatibility with modern systems while staying lightweight.
2021–2025—>Still actively available in repositories. Maintained primarily by volunteers. Used in embedded systems, retro computing, low-resource PCs, and minimalistic Linux desktops.

⚙️ Features Over Time

Graphical Interface: Lightweight GUI with GTK+.

HTML Support: HTML 4.0, tables, frames, and basic CSS.

No JavaScript: For speed, simplicity, and security.

Security: SSL/HTTPS support added early (2002+).

Bookmarks & Navigation: Basic bookmarks, session restore, simple UI navigation.

Memory Usage: Extremely low (~1–2 MB), suitable for old or embedded systems.

Platforms: Runs on Unix/Linux, Windows, BSD, and other POSIX systems.

🔀 Related or Inspired Projects

Links / ELinks – Text-based browsers for low-resource environments.

surf – Minimalist Unix graphical browser.

xombrero – Lightweight, keyboard-centric browser (now discontinued).

💡 Legacy & Impact

Dillo is a classic example of a lightweight web browser focusing on minimalism.

It inspired other lightweight browsers and remains a reference for low-resource computing.

Despite lacking modern web features (JS, advanced CSS), it continues to be valued for fast startup, low memory use, and security.

Dillo is a free, open-source, multi-platform web browser written in C and C++. Its defining characteristic is that it is extremely fast and lightweight, often using orders of magnitude less memory and CPU than mainstream browsers. This comes at the cost of not supporting complex modern web standards like JavaScript, advanced CSS, or complex web applications.

The Full History of the Dillo Web Browser

The history of Dillo is a story of a consistent, principled stand for efficiency and simplicity in the face of an increasingly complex and bloated web.

1. The Genesis: A Master’s Thesis Project (1999)

The story of Dillo begins not as a mainstream product, but as an academic endeavor.

Founder: The project was started by Jorge Arellano Cid in Chile.

Original Goal: Dillo began as Cid’s master’s thesis project in 1999. The initial goal was to create a very basic, functional web browser that could run on limited hardware.

Initial Foundation: The first versions were built upon the GTK+ 1.2 toolkit and a custom, rudimentary rendering engine.

2. Early Development and Public Release (1999-2003)

After the thesis was completed, Jorge continued developing Dillo, releasing it to the public.

Rise in Popularity: Dillo quickly found a niche among users of old computers, minimalist Linux distributions (like Damn Small Linux), and developers who needed a lightning-fast browser to view static HTML content.

Key Features Established:

Rewriting the Engine (Dillo 2): Around 2003, a major effort began to rewrite the core rendering engine to be more robust and capable of handling basic CSS. This led to the development of Dillo 2.

3. The Fork and Community Effort (2004-2008)

As the project grew, so did its developer community. A significant event occurred in 2004-2005.

The dillo2 Fork: A group of developers, wanting to move development forward more rapidly, created a fork called dillo2. This fork introduced major improvements, including better CSS support and a more modular codebase.

Reunification: Eventually, the efforts of the dillo2 fork were merged back into the mainline Dillo project, strengthening it significantly. This period saw Dillo at its peak of active community contribution.

4. Stagnation and the Dillo 3 Effort (2009-2015)

The late 2000s and early 2010s were a challenging time for Dillo.

GTK+ 2 Transition: The transition from the aging GTK+ 1.2 to GTK+ 2 was a long and difficult process, as it required significant changes to the codebase.

The Modern Web Problem: The web was rapidly standardizing on technologies that Dillo explicitly did not support (JavaScript, AJAX, HTML5). This made more and more websites “break” in Dillo, showing only basic text or error messages.

Dillo 3 Stalled: An ambitious plan for Dillo 3, which promised a new, cleaner codebase and better CSS support, never fully materialized. Development slowed to a crawl as maintainers had less time and the technical challenges grew.

5. The Florians and Revival Attempts (2016-Present)

The project was saved from complete abandonment by a new maintainer.

New Steward: A developer known as “the Florian” (Sebastian Geerken and later others) took over maintenance.

Focus on Stability: The focus shifted from adding new features to keeping Dillo compiling and running on modern systems (e.g., migrating from GTK+ 2 to GTK+ 3).

Niche Maintenance: Dillo is now in a state of “life support” maintenance. It is kept alive by a very small team that applies critical bug fixes and porting patches. It is not actively developed to support new web standards.

Key Milestones Timeline

Date (Approx.)—>Milestone
1999—>Project begins as the master’s thesis of Jorge Arellano Cid.
2000-2002—>First public releases. Gains a cult following for its incredible speed.
2003-2004—>Planning and work begins on the Dillo 2 engine rewrite.
2004-2005—>The dillo2 fork emerges, later merging back into the main project.
2006-2008—>Peak of community development and feature integration.
2009-2015—>Era of Stagnation. Struggle with GTK+2 transition; Dillo 3 plan fails.
2016-Present—>Maintenance Mode. “The Florians” take over, porting the code to GTK+3 to keep it functional on modern OSes.

Legacy and Significance

Dillo’s legacy is powerful and clear, even as its practical use has diminished.

A Benchmark for Performance: Dillo remains the gold standard for what “fast and lightweight” means in a web browser. It is often used as a benchmark to show just how bloated modern web browsing has become.

The Philosophy of Simplicity: It is a pure embodiment of the Unix philosophy for a graphical application: do one thing (display simple HTML) and do it exceptionally well.

Critical for Embedded Systems: Dillo is still incredibly useful in embedded Linux systems, kiosks, and any environment where resources are extremely constrained and the web-browsing needs are limited to simple, static information display.

A Time Capsule: Using Dillo today is like looking into a time capsule of the late 1990s web, where content and simple structure were prioritized over complex interaction.

In conclusion, the history of Dillo is not a story of failure, but one of unwavering dedication to a specific ideal. It chose the path of minimalism and efficiency, and while that path ultimately made it incompatible with the modern web, it secured its place as a legendary tool for a specific, and still relevant, set of problems.