Written on 2024-12-15 by Rodrigo Arias Mallo
Back in 1999, a group of developers lead by Jorge Arellano Cid forked the
Gzilla/Armadillo code originally
developed by Raph Levien, and began working on what is now known as the Dillo
web browser.
Today, as of December of 2024, Dillo is 25 years old!
During this long journey, the project has seen a lot of changes and has
stalled several times, but it managed to survive to this day. As a commemoration
of this milestone, so I wanted to write a short history of the project.
Notice that Jorge had lead the project from 1999 until 2019, and as of
today, we don’t have more news about him anymore. I hope he is okay and just
decided to move on to other projects. Since then, I (Rodrigo) decided to
resurrect the project and bring it back to life. I have no relationship with the
previous developers, but I try to do my best to keep the original goals intact.
This document tries to tells the history as I have observed it through the pieces I was
able to collect from the
mailing
list, the
changelog
and the
git
history.
GTK period (1999 – 2006)
When Dillo was forked, it was using GTK 1.0 as the UI library. The first
releases were done in December of 1999 as recorded in the ChangeLog. At the
time, this is how Gzilla 0.3.9 looked like:
During the initial development, Jorge first designed and wrote the naming
convention for the function names (like prefixing them with a_ when they are
public) or using 3 spaces for indentation, and began adjusting the code base to
follow the same convention.
On March of 2000, the license was changed to the GPLv3 with the permission of
Raph Levien (the main developer of Gzilla/Armadillo).
The browser experimented a large rewrite with the idea to maintain several
flows of communication following a signal driven approach. This work ended up in the
publication
Network programming
internals of the Dillo Web browser by Jorge Arellano-Cid and H.H.
Von Brand. This work would later derive in the Concomitant Control Chain (CCC),
the mechanism that Dillo still uses today to track multiple connections and
among its internal modules.
Sebastian Geerken began working on the code base at least since June of 2000.
First submitting small patches and then moving to the rendering engine, of which
he became the main architect. The rendering engine is one of the most important
components of the browser, which essentially reads a tree of elements and
determines the size and position of each element on the screen, like the
words of paragraphs and images.
The support for HTML and CSS features started to grow during the coming
years, specially for tables and text elements.
Shortly after GTK2 was released, the team was considering porting Dillo to
it, but there were some concerns regarding the complexity and size of the new
GTK version.
On October of 2003,
Jorge asked the FLTK maintainer Michael Sweet if it would be feasible to
port Dillo to FLTK, as it was considered to align better with the objectives of
speed and stability:
We were following our plan to port dillo from GTK1 (currently
used TK) to GTK2, when one of our list subscribers suggested
considering FLTK because of shared philosophy backgrounds
The team decided to focus on FLTK 2 instead of GTK 2.0, as it was considered
far more bloated and slow. Notice that at the time, FLTK 2 was not yet released,
but is was planning to be released “soon”.
On August 2004, Sebastian decided to make an interesting design decision,
to make the
Dillo widget toolkit independent. This way it was posible to continue the
development of GTK1 and FLTK2 in parallel, among other benefits.
The most complex part is certainly Dw, since it is tightly bound to
Gtk+. By all means, I want to prevent, that there exist different
versions of Dw, with different features (e.g., when the development of
the Gtk+ version continues, while the FLTK version is developed),
which are hard to integrate.For this reason (and others), I’m currently working on a redesign of
Dw, which will make Dw toolkit independant. This is not the single
goal of this redesign, it will also make some other features possible,
e.g. a preview window, in which the whole page may be seen with
reduced size, also, it will make reusage of Dw within graphical
plugins possibel, and some more. (Actually, the idea for this design
is already older, except the platform independency, but this was simple
to add.)
During this period, the DPI mechanism (plugins) was improved and some
functionality was moved to external programs that talk to the browser via the
DPI protocol, like the downloads, bookmarks, FTP and also HTTPS. The version
0.8.3 released on October, 2004 had already HTTPS support. Here is how it looked
like (still using GTK1):
During the following years, the development of the FLTK port was underway.
The functionality that was provided by glib was implemented in a custom Dlib
library so Dillo would not need to depend on glib anymore.
On February 2005, Jorge and Sebastian gave
a
talk at FOSDEM about the Dillo browser. Unfortunately, there is no
recording of that talk. But shortly after, Jorge gave another talk at LSM in
2005 which is was recorded, which was the first time the FLTK2 implementation
was shown.
The last release that still used GTK1 was 0.8.6 on April, 2006. We will have
to wait two years until the next release 2.0.0 was finally published with the
port to FLTK2 completed.
FLTK 2 period (2005 – 2011)
The porting to FLTK2 was intended to make the browser smaller and provide other
features like antialiasing. On April 2005, Jorge reported that the port to FLTK2
was making
great
progress.
Here are some good news with our current progress in porting
dillo to FLTK. It has being going-on very fast and we have made great progress
so far.
Here is how the browser looked like with FTLK2:
During this time however, the source code for the new FLTK2 port was not
available in the CVS to the public. Instead, Jorge was focusing on rising
funding to cover the project development from some interested companies.
On March 2006, Jorge reported that so far
it
was not being successful in attracting funding.
The project faced a serious risk of stalling.
After mid 2006, there were no more releases of Dillo until 2008, and so far
no success in getting more developers involved or funding for the project. The
project was considered frozen or stalled and the FLTK2 code remained closed
source.
On April 2007, Jorge
reports
that he had intentions to release the FLTK2 port
as soon as Sebastian agrees.
In fact, I think it was more or less 6 months ago, after some
emails with Andrew Tanenbaum, who finally helped me to see that
it was a good time to release the code again.Since then, I’ve tried to contact Sebastian to agree on this.
On September 30, 2007, Jorge finally
announces that the FLTK2 port is now
available:
This is an alpha release of the next generation of the Dillo
web browser. The code underwent a major rewrite: significant
parts of the codebase were ported to C++, and the rendering
engine now uses the FLTK2 library instead of GTK1.Please read the README inside dillo’s tarball.
Developers willing to join the project and contribute are
highly encouraged. Sebastian did an excellent work documenting
the new dillo widget engine (just run doxygen inside DW tree).
This move started a lot of patches from other developers that were quickly
integrated in the FLTK2 port. These contributions pushed Dillo towards an active
state of development again.
On September of 2008, Jorge
announced the support for tabs, which was
included for the release. After a lot of bug fixing, the next version based on
FLTK2 was ready and on October of 2008, Dillo 2.0.0 was finally released.
A year later, on July of 2009,
Jorge
announces that he is now a father, and
his time for developing Dillo will (understandably) be affected.
I’m quite happy to let you know that yesterday 19 Aug [July],
my first daughter Lisa was born!Everything is OK, we’re vey happy with this “release” 🙂 and I just wanted to
communicate it here, so you more or less know or understand my activities (or
lack of) in the next days.
More features and bug fixes were added in the coming releases, until the last
release of the 2.X series, the version 2.2.1 released on 2011. During this
period, we don’t observe more patches from Sebastian or emails in the mailing
list.
Here is how Dillo was looking in the 2.2 version, very similar as how it
looks today:
During this period, another problem was coming in FLTK. The
development for
FLTK2 was considered stalled and there was no official version released.
This caused issued in downstream distributions, as Dillo required to link with
a FLTK package that was not available.
So, the team decided to switch to FLTK 1.3 as soon as it was released, and bump
Dillo to the series 3.X.
FLTK 1.3 period (2011 – 2016)
On June 2011, with the FLTK 1.3 release done, the port of Dillo to FLTK 1.3 was
underway. Only a few months later, the first 3.0.0 release using FLTK 1.3 was
published.
On July of 2012, Sebastian presented a new hyphenation algorithm that
implements the same mechanism used in TeX. This new implementation makes its way
to the 3.0.3 release on April of 2013.
Several releases were made until the version 3.0.5 on June 2015.
During these last two years, we see a shift in the amount of commits
introduced by Sebastian, which grow quite substantially.
On that time, Sebastian was working on the GROWS redesign, which changed the way
the size of the widgets (elements of the page) where computed.
Sadly, on October 2016, Sebastian
passed away, leaving much of his work not included into a new release.
Since then, the development quickly stalled until in 2019 Jorge sent his last
email recorded
by the mailing list, recommending a user to simply use the current version
of the repository, rather than waiting for the 3.1 release:
> According to the info on
> https://hg.dillo.org/dillo/raw-file/default/ChangeLog, dillo-3.1 [not
released yet].
>
> I will probably wait until they release it officially.IMHO, you should get it. It’s being stable for years.
—
Cheers
Jorge.-
After this moment, the project began to deteriorate. On 2022 the DNS domain
of dillo.org was lost, causing the website, the
mercurial repository, the mailing list and the email server to disappear.
The project quickly became abandoned, as there was no more developer activity
anywhere. The dillo.org site now became a weird zombie copy of the once original
website, but now plagued with SPAM in a WordPress blog.
The resurrection (2024 – present)
On December of 2023, I began spending some time patching Dillo to make it build
again. I tried to fix some simple bugs, and when I saw that the Atari forum had
managed to port Dillo to Atari (!) based on my repo I though that it may be
feasible to try to resurrect it. I commented it on
Hacker News and it
got surprised on the of interest it drew.
I first made a GitHub organization to hold the Git repositories and used the
GitHub pages to make a new Dillo website. I tried to get a copy of all materials
I could, and upload them to the new website and mailing list.
I tried to fix all the issues to finally make the 3.1.0 release, and after
some months of work in my free time, I managed to release it on May of 2024. It
caught the attention of
several
news
sites
and soon later it made its way to several
Linux distributions.
As of today, 15 of December of 2024, I continue to maintain the project, and
we are getting some new contributors which help with patches and discussion
about the development. We are still far from having enough developers to cover
all the issues, but we are slowly making some progress.
The last release of Dillo is 3.1.1, and this is what is looks like when
loading the new Dillo website:
