ZIM file format

The ZIM file format is based on the old and deprecated Zeno File Format. See also a walk through example at ZIM File Example. It starts with a header, which is described here:

Header
A ZIM file starts with a header. This is offset 0.

Length in bytes, all types are little-endian.

All integers are unsigned integers (uint_16, uint_32, uint_64).

Major version is updated when an incompatible change is integrated in the format (a lib made for a version N will probably not be able to read a version N+1)

Minor version is updated when an compatible change is integrated (a lib made for a minor version n will be able to read a version n+1)

There are currently 2 major versions :
 * The version 5
 * The version 6 (the same that version 5 + potential extended cluster)

MIME Type List (mimeListPos)
The MIME type list always follows directly after the header, so the mimeListPos also defines the end and size of the ZIM file header.

The MIME types in this list are zero terminated strings. An empty string marks the end of the MIME type list.

URL Pointer List (urlPtrPos)
The URL pointer list is a list of 8 byte offsets to the directory entries.

The directory entries are always ordered by URL. Ordering is simply done by comparing the URL strings.

Since directory entries have variable sizes this is needed for random access.

Zimlib caches directory entries and references the cached entries via the URL pointers.

Title Pointer List (titlePtrPos)
The title pointer list is a list of article indices ordered by title. The title pointer list actually points to entries in the URL pointer list. Note that the title pointers are only 4 bytes. They are not offsets in the file but article numbers. To get the offset of an article from the title pointer list, you have to look it up in the URL pointer list.

The indirection from titles via URLs to directory entries has two reasons:
 * the pointer list is only half in size as 4 bytes are enough for each entry
 * accessing directory entries by title also makes use of cached directory entries which are referenced by the URL pointers, as implemented in zimlib.

Directory Entries
Directory entries hold the meta information about all articles, images and other objects in a ZIM file.

There are many types of directory entries:

Cluster Pointer List (clusterPtrPos)
The cluster pointer list is a list of 8 byte offsets which point to all data clusters in a ZIM file.

Clusters
The clusters contain the actual data of the directory entries. Clusters can be compressed or uncompressed. The purpose of the clusters are that data of more than one directory entry can be compressed inside one cluster, making the compression much more efficient. Typically clusters have a size of about 1 MB.

The first byte of the cluster identifies some information about the cluster.

The first fourth low bits identifies if the cluster is compressed (4) or not (0). The default is uncompressed indicated by a value of 0 or 1 (obsoleted, inherited by Zeno) while compressed clusters are indicated by a value of 4 which indicates LZMA2 compression (or more precisely XZ, since there is a XZ header). There have been other compression algorithms used before (2: zlib, 3: bzip2) which have been removed. The zimlib uses xz-utils as a C++ implementation of lzma2, for Java see XZ-Java.

The firth bit identifies if the cluster is extended or not : A cluster can be extended only if the zim major version is 6. Else (major version == 5) cluster will always be not extended.
 * By default (5th bit == 0) the cluster is not extended. It means that the offsets are stored in a 4 bytes length integer. Thus contents stored in the cluster cannot exceed 4Go.
 * If the cluster is extended (5th bit == 1), the offsets are stored in 8 bytes length integer. Thus contents stored in the cluster can exceed 4Go.

To find the data of a specific directory entry within a cluster the uncompressed cluster has a list of pointers to blobs within the uncompressed cluster after the first byte.

The offset addresses uncompressed data. The last pointer points to the end of the data area. So there is always one more offset than blobs. Since the first offset points to the start of the first data, the number of offsets can be determined by dividing this offset by OFFSET_SIZE. The size of one blob is calculated by the difference of two consecutive offsets.

Namespaces
Namespaces seperate different types of directory entries - which might have the same title - stored in the ZIM File Format.

They can be distinguished by prepending the article namespace before the article name in the URL path, eg. http://localhost/A/Articlename.

URLs
ZIM contents are addressed using URLs fitting the following pattern: /. The references in articles HTML code ( ,  , etc.) are URL-encoded following the RFC 1738 rules.

Absolute URLs, ie. with a leading slash (/) are forbidden, because this avoid including the ZIM contents in any HTTP sub-hierachy. ZIM contents URLs must consequently be relative.

The URLs in the UrlPointerlist are not encoded. Some readers process the requests that already do the decoding internally whereas most readers will handle the URLs directly. In this case you have to do the decoding before you pass the parameter to zimlib, but zimlib already provides a method to do so.

Local Anchors
Many articles - especially when a table of contents is used - use local anchors to jump within an article.

jump to article foo, headline 1

The browser handles these local anchors by itself. It will determine if another article has to be loaded (local anchor inside another article than the currently shown) and will send a request only with the article URL without the local anchor - in our example "../A/foo". After the article has been loaded the browser will then search for the local anchor tag and jump to the right location.

If you use a common rendering engine or HTML widget you don't have to care for this cases, you can just use the requests as they are submitted by the engine / widget.

Should you render the article contents by yourself you have to consider this and take care of it before you hand requests to zimlib.

Character Encoding
The standard encoding for ZIM file content is UTF-8. So both article data and URLs should be handled accordingly.

Old Zeno files used a mixture of Latin1 and UTF-8 so there is still some "auto detection" code left in the zimlib, a workaround for this bug. This will be removed in future versions. Zeno files are not supported anymore.

Integer Encoding
For integer encoding the same algorithm as UTF-8 encoding is used. This encoding is also known as "integer compression". It safes some bytes by using variable lengths of integer fields, depending on the actual value of the number.

See also http://en.wikipedia.org/wiki/UTF-8#Design.

Old Zeno files used the QUnicode library instead. By switching to UTF-8 the new format is more standard-adherent and easier to understand.

Split ZIM files
ZIM files can be split in multiple chunks. This is necessary to be able to store big (over 4GB for example) ZIM files to limited file systems (like FAT32). That said, the chunks can be of any size, but the naming is really important. The ZIM file chunks should be named like following (the file name extensions matter): foobar.zimaa, foobar.zimab, foobar.zimac...