First of all, let me thank everyone who has commented on this thread. Sorry
about not responding earlier. My exams are going on. You can certainly
expect more response from me once they are over.
On Tue, Apr 30, 2013 at 4:18 AM, Emmanuel Engelhart
Before commenting your proposal, let me thank:
* Quim for having renamed this thread... I wouldn't have got a chance to
read it otherwise.
* Gnosygnu and Sumana for their previous answers.
Your emails points three problems:
(1) The size of the offline dumps
(2) Server mode of the offline solution
(3) The need of incremental updates
Regarding (1), I disagree. We have the ZIM format which is open, has an
extremly efficient standard implementation, provides high compression
rates and fast random access: http://www.openzim.org
Regarding (2), Kiwix, which is a ZIM reader, already does it: you can
either share Kiwix on a network disk or use Kiwix HTTP compatible daemon
called kiwix-serve: http://www.kiwix.org/wiki/Kiwix-serve
Regarding (3), I agree. This is an old feature request in the openZIM
project. It's both on the roadmap and in the bug tracker:
But, I also think the solution you propose isn't adapted to the problem.
Setting up a Mediawiki is not easy, it's resource intensive and you
don't need all this power (of the software setup) for the usage you want
On the other side, with ZIM you have a format which
provides all what
you need, runs on devices which costs only a few dozens of USD and we
will make this incremental update trivial for the final user (it's just
a matter of time ;).
I don't think power is much of a priority, but I agree the ZIM format would
be easier, since it directly reads from the ZIM file
So to fix that problem, there is my approach: we should implement two
tools I call "zimdiff" and "zimpatch":
* zimdiff is a tool able to compute the difference between two ZIM files
* zimpatch is a tool able to patch a ZIM file with a ZIM diff file
The incrementation process would be:
* Compute a ZIM diff file (done by the ZIM provider)
* Download and path the "old" ZIM file with the ZIM diff file (done by
We could implement two modes for zimpatch, "leasy" and "normal":
* leasy mode: simple merge of the file and rewriting of the index (fast
but need a lot of mass storage)
* normal mode: recompute a new file (slow but need less mass storage)
Regarding the ZIM diff file format... the discussion is open, but it
looks like we could simply reuse the ZIM format and zimpatch would work
like a "zimmerge" (does not exist, it's just for the explanation).
Everything could be done IMO in "only" a few hundreds of smart lines of
C++. I would be really surprised if this need more than 2000 lines. But,
to do that, we need a pretty talentuous C++ developer, maybe you?
Yes, this is a quite easy task. I can do this. I can go through the ZIM
format and the zimlib library in a few days.
Regarding the *zimpatch*, I think it would be better to implement both
methods( although I prefer the 2nd one). The user can then select the one
which he wants , depending on his configuration.
Lastly, we can add the *zimdiff as an automated task in the server*.
zimpatch and downloading the zim file can also be automated and added to
If there's time left, I can port the zimlib library to python or PHP, so it
becomes easier for people to hack.
If you have any more suggestions, please comment. I'll submit the proposal
in ~ 12 hours.(again, exams).
If your or someone else is interested we would
probably be able to find
PS: Wikimedia has an offline centric mailing list, let me add it in CC:
Le 26/04/2013 22:27, Kiran Mathew Koshy a écrit :
I have an own idea for my GSoC project that I'd like to share with you.
Its not a perfect one, so please forgive any mistakes.
The project is related to the existing GSoC project "*Incremental Data
*" , but is in no way a replacement for it.
For a long time, a lot of offline solutions for Wikipedia have sprung up
the internet. All of these have been unofficial
solutions, and have
limitations. A major problem is the* increasing size of the data dumps*,
and the problem of *updating the local content. *
Consider the situation in a place where internet is costly/
unavailable.(For the purpose of discussion, lets consider a school in a
world country.) Internet speeds are extremely
slow, and accessing
directly from the web is out of the question.
Such a school would greatly benefit from an instance of Wikipedia on a
local server. Now up to here, the school can use any of the freely
available offline Wikipedia solutions to make a local instance. The
arises when the database in the local instance
becomes obsolete. The
is then required to download an entire new
dump(approx. 10 GB in size)
load it into the database.
Another problem that arises is that most 3rd part programs *do not allow
network access*, and a new instance of the database is required(approx.
GB) on each installation.For instance, in a
school with around 50
each desktop would require a 40 GB database.
Plus, *updating* them
even more difficult.
So here's my *idea*:
Modify the existing MediaWiki software and to add a few PHP/Python
which will automatically update the database and
will run in the
background.(Details on how the update is done is described later).
Initially, the MediaWiki(modified) will take an XML dump/ SQL dump (SQL
dump preferred) as input and will create the local instance of Wikipedia.
Later on, the updates will be added to the database automatically by the
The installation process is extremely easy, it just requires a server
package like XAMPP and the MediaWiki bundle.
Process of updating:
There will be two methods of updating the server. Both will be
into the MediaWiki bundle. Method 2 requires the
incremental data dumps, so it can be completed only after the
is available. Perhaps I can collaborate with the
student selected for
incremental data dumps.
Method 1: (online update) A list of all pages are made and published by
Wikipedia. This can be in an XML format. The only information in the XML
file will be the page IDs and the last-touched date. This file will be
downloaded by the MediaWiki bundle, and the page IDs will be compared
the pages of the existing local database.
case 1: A new page ID in XML file: denotes a new page added.
case 2: A page which is present in the local database is not among the
IDs- denotes a deleted page.
case 3: A page in the local database has a different 'last touched'
compared to the one in the local database- denotes an edited page.
In each case, the change is made in the local database and if the new
data is required, the data is obtained using
These offline instances of Wikipedia will be only used in cases where the
internet speeds are very low, so they *won't cause much load on the
method 2: (offline update): (Requires the functionality of the existing
project "Incremental data dumps"):
In this case, the incremental data dumps are downloaded by the
user(admin) and fed to the MediaWiki installation the same way the
dump is fed(as a normal file), and the
corresponding changes are made by
the bundle. Since I'm not aware of the XML format used in incremental
updates, I cannot describe it now.
Advantages : An offline solution can be provided for regions where
access is a scarce resource. this would greatly
, and would help in making the world's
information more free and openly
available to everyone.
All comments are welcome !
PS: about me: I'm a 2nd year undergraduate student in Indian Institute of
Technology, Patna. I code for fun.
hobbies: CUDA programming, robotics, etc.
Kiran Mathew Koshy