diff --git a/swh/core/tarball.py b/swh/core/tarball.py
index 446328f..d9ee8e8 100644
--- a/swh/core/tarball.py
+++ b/swh/core/tarball.py
@@ -1,142 +1,144 @@
 # Copyright (C) 2015-2017  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import os
 import shutil
 import stat
 import tarfile
 import zipfile
 
 from . import utils
 
 
 def unpack_specific_tar(tarpath: str, extract_dir: str) -> str:
     """Unpack .tar.Z file and returns the full path to the uncompressed
     directory.
 
     Raises
         ReadError in case of issue uncompressing the archive.
 
     """
     try:
         if not os.path.exists(tarpath):
             raise ValueError(f'{tarpath} not found')
         filename = os.path.basename(tarpath)
         output_directory = os.path.join(extract_dir, filename)
         os.makedirs(output_directory, exist_ok=True)
         from subprocess import run
         run(['tar', 'xf', tarpath, '-C', output_directory])
         # data = os.listdir(output_directory)
         # assert len(data) > 0
         return output_directory
     except Exception as e:
         raise shutil.ReadError(
             f'Unable to uncompress {tarpath} to {extract_dir}. Reason: {e}')
 
 
 def register_new_archive_formats():
     """Register new archive formats to uncompress
 
     """
     registered_formats = [f[0] for f in shutil.get_unpack_formats()]
     for format_id in ADDITIONAL_ARCHIVE_FORMATS:
         name = format_id[0]
         if name in registered_formats:
             continue
         shutil.register_unpack_format(
             name=format_id[0], extensions=format_id[1], function=format_id[2])
 
 
 def uncompress(tarpath: str, dest: str):
     """Uncompress tarpath to dest folder if tarball is supported and safe.
        Safe means, no file will be uncompressed outside of dirpath.
 
        Note that this fixes permissions after successfully
        uncompressing the archive.
 
     Args:
         tarpath: path to tarball to uncompress
         dest: the destination folder where to uncompress the tarball
 
     Returns:
         The nature of the tarball, zip or tar.
 
     Raises:
         ValueError when the archive is not supported
 
     """
     try:
         shutil.unpack_archive(tarpath, extract_dir=dest)
     except shutil.ReadError:
         raise ValueError(f'File {tarpath} is not a supported archive.')
 
     # Fix permissions
     for dirpath, _, fnames in os.walk(dest):
         os.chmod(dirpath, 0o755)
         for fname in fnames:
             fpath = os.path.join(dirpath, fname)
             if not os.path.islink(fpath):
                 fpath_exec = os.stat(fpath).st_mode & stat.S_IXUSR
                 if not fpath_exec:
                     os.chmod(fpath, 0o644)
 
 
 def _ls(rootdir):
     """Generator of filepath, filename from rootdir.
 
     """
     for dirpath, dirnames, fnames in os.walk(rootdir):
         for fname in (dirnames+fnames):
             fpath = os.path.join(dirpath, fname)
             fname = utils.commonname(rootdir, fpath)
             yield fpath, fname
 
 
 def _compress_zip(tarpath, files):
     """Compress dirpath's content as tarpath.
 
     """
     with zipfile.ZipFile(tarpath, 'w') as z:
         for fpath, fname in files:
             z.write(fpath, arcname=fname)
 
 
 def _compress_tar(tarpath, files):
     """Compress dirpath's content as tarpath.
 
     """
     with tarfile.open(tarpath, 'w:bz2') as t:
         for fpath, fname in files:
             t.add(fpath, arcname=fname, recursive=False)
 
 
 def compress(tarpath, nature, dirpath_or_files):
     """Create a tarball tarpath with nature nature.
     The content of the tarball is either dirpath's content (if representing
     a directory path) or dirpath's iterable contents.
 
     Compress the directory dirpath's content to a tarball.
     The tarball being dumped at tarpath.
     The nature of the tarball is determined by the nature argument.
 
     """
     if isinstance(dirpath_or_files, str):
         files = _ls(dirpath_or_files)
     else:  # iterable of 'filepath, filename'
         files = dirpath_or_files
 
     if nature == 'zip':
         _compress_zip(tarpath, files)
     else:
         _compress_tar(tarpath, files)
 
     return tarpath
 
 
 # Additional uncompression archive format support
 ADDITIONAL_ARCHIVE_FORMATS = [
     # name  , extensions, function
     ('tar.Z|x', ['.tar.Z', '.tar.x'], unpack_specific_tar),
+    # FIXME: make this optional depending on the runtime lzip package install
+    ('tar.lz', ['.tar.lz'], unpack_specific_tar),
 ]
diff --git a/swh/core/tests/data/archives/hello.tar.lz b/swh/core/tests/data/archives/hello.tar.lz
new file mode 100644
index 0000000..8195e33
Binary files /dev/null and b/swh/core/tests/data/archives/hello.tar.lz differ