Ideas for image compression feature [add more quality options]

SWEETGOOD · March 11, 2026, 9:11pm

This topic has been discussed widely and unfortunately the default compression algorithm is not really good.

Regarding your question: You can already achieve this by sending the image as a file. Then the original quality without any compression will be preserved (but also the original file size).

I also think there should at least be another “good” compression option in the list as well. I quote what I wrote in another thread about that:

Image compression

Another frustrating feature is the image compression. As I described here the default image compression “balanced” is showing visible compression artifacts (from a viewers perspective) and there’s no option to choose a less destructive compression level (apart from sending the original probably oversized file producing other problems).

I want to add that the argument of sending images as file in original quality (which was already repeated many times) as a workaround is not sufficient for most use cases.

The FAQ states about the default compression algorithm “This is ideal for everyday communication.” – and from my perspective this is not the case. The quality is worse than the default with any other messenger. I think they should be the reference when talking about everyday communication as billions of people are using them day by day. So an option which does compression but in a less destructive way could be a simple fix.

Sending pictures uncompressed comes also with another very bad downside:
Storage limits on all sides

I don’t want to have 500MB wasted on ALL of my devices I use Delta Chat on just because a family member sent me all pictures of the last vacation as files because Delta Chats compression algorithm is too bad to send them as images. A normal compressed JPG has around 250 - 500KB, an uncompressed one 5-7 MB. That’s a huge difference.

EDIT:
I think I found the “issue” why the devs are not just implementing it. They would have to adapt the CORE library too. The quality settings in the Delta Chat Desktop client were changed 2 years ago and the compression does NOT take place there (I thought that before).

You can get a picture of how the compression is implemented by taking a look at these files:

github.com/chatmail/core

src/blob.rs

3c5af7a55


      
              let viewtype = &mut Viewtype::Image;
              let is_avatar = true;
              self.check_or_recode_to_size(
                  context, None, // The name of an avatar doesn't matter
                  viewtype, max_wh, max_bytes, is_avatar,
              )?;
          
              Ok(())
          }
          
          /// Checks or recodes an image pointed by the [BlobObject] so that it fits into limits on the
          /// image width, height and file size specified by the config.
          ///
          /// Recoding is only done for [`Viewtype::Image`]. For [`Viewtype::File`], if it's a correct
          /// image, `*viewtype` is set to [`Viewtype::Image`].
          ///
          /// On some platforms images are passed to Core as [`Viewtype::Sticker`]. We recheck if the
          /// image is a true sticker assuming that it must have at least one fully transparent corner,
          /// otherwise `*viewtype` is set to [`Viewtype::Image`].
          pub async fn check_or_recode_image(
              &mut self,

github.com/chatmail/core

deltachat-rpc-client/src/deltachat_rpc_client/const.py

3c5af7a55


      
          
          
          # "Lp" means "login parameters"
          class LpAuthFlag(IntEnum):
              """Authorization flags."""
          
              OAUTH2 = 0x2
              NORMAL = 0x4
          
          
          class MediaQuality(IntEnum):
              """Media quality setting."""
          
              BALANCED = 0
              WORSE = 1
          
          
          class ProviderStatus(IntEnum):
              """Provider status according to manual testing."""
          
              OK = 1

github.com/chatmail/core

deltachat-ffi/deltachat.h

3c5af7a55


      
          * ~~~
          * dc_msg_t* msg = dc_msg_new(context, DC_MSG_IMAGE);
          *
          * dc_msg_set_file_and_deduplicate(msg, "/file/to/send.jpg", NULL, NULL);
          * dc_send_msg(context, chat_id, msg);
          *
          * dc_msg_unref(msg);
          * ~~~
          *
          * If you send images with the #DC_MSG_IMAGE type,
          * they will be recoded to a reasonable size before sending, if possible
          * (cmp the dc_set_config()-option `media_quality`).
          * If that fails, is not possible, or the image is already small enough, the image is sent as original.
          * If you want images to be always sent as the original file, use the #DC_MSG_FILE type.
          *
          * Videos and other file types are currently not recoded by the library.
          *
          * @memberof dc_context_t
          * @param context The context object as returned from dc_context_new().
          * @param chat_id The chat ID to send the message to.
          * @param msg The message object to send to the chat defined by the chat ID.

They not only set a compression factor (jpeg_quality) but also a target file size (max_bytes) (which should not be exceeded) and a target resolution (target_wh), see

github.com/chatmail/core

src/constants.rs

3c5af7a55


      
          pub const DC_LP_AUTH_OAUTH2: i32 = 0x2;
          
          /// Force NORMAL authorization, this is the default.
          /// If this flag is set, automatic configuration is skipped.
          pub const DC_LP_AUTH_NORMAL: i32 = 0x4;
          
          /// if none of these flags are set, the default is chosen
          pub const DC_LP_AUTH_FLAGS: i32 = DC_LP_AUTH_OAUTH2 | DC_LP_AUTH_NORMAL;
          
          // max. weight of images to send w/o recoding
          pub const BALANCED_IMAGE_BYTES: usize = 500_000;
          pub const WORSE_IMAGE_BYTES: usize = 130_000;
          
          // max. width/height and bytes of an avatar
          pub(crate) const BALANCED_AVATAR_SIZE: u32 = 512;
          pub(crate) const BALANCED_AVATAR_BYTES: usize = 60_000;
          pub(crate) const WORSE_AVATAR_SIZE: u32 = 128;
          pub(crate) const WORSE_AVATAR_BYTES: usize = 20_000; // this also fits to Outlook servers don't allowing headers larger than 32k.
          
          // max. width/height of images scaled down because of being too huge
          pub const BALANCED_IMAGE_SIZE: u32 = 1280;

github.com/chatmail/core

src/constants.rs

3c5af7a55


      
          pub const BALANCED_IMAGE_BYTES: usize = 500_000;
          pub const WORSE_IMAGE_BYTES: usize = 130_000;
          
          // max. width/height and bytes of an avatar
          pub(crate) const BALANCED_AVATAR_SIZE: u32 = 512;
          pub(crate) const BALANCED_AVATAR_BYTES: usize = 60_000;
          pub(crate) const WORSE_AVATAR_SIZE: u32 = 128;
          pub(crate) const WORSE_AVATAR_BYTES: usize = 20_000; // this also fits to Outlook servers don't allowing headers larger than 32k.
          
          // max. width/height of images scaled down because of being too huge
          pub const BALANCED_IMAGE_SIZE: u32 = 1280;
          pub const WORSE_IMAGE_SIZE: u32 = 640;
          
          /// Limit for received images size. Bigger images become `Viewtype::File` to avoid excessive memory
          /// usage by UIs.
          pub const MAX_RCVD_IMAGE_PIXELS: u32 = 50_000_000;
          
          // Key for the folder configuration version (see below).
          pub(crate) const DC_FOLDERS_CONFIGURED_KEY: &str = "folders_configured";
          // this value can be increased if the folder configuration is changed and must be redone on next program start
          pub(crate) const DC_FOLDERS_CONFIGURED_VERSION: i32 = 5;

Also the image quality is hardcoded to 75 (85 would be my selection for good results):

github.com/chatmail/core

src/blob.rs

3c5af7a55


      
          // max_wh is the maximum image width and height, i.e. the resolution-limit.
          // target_wh target-resolution for resizing the image.
          let exceeds_wh = img.width() > max_wh || img.height() > max_wh;
          let mut target_wh = if exceeds_wh {
              max_wh
          } else {
              max(img.width(), img.height())
          };
          let exceeds_max_bytes = nr_bytes > max_bytes as u64;
          
          let jpeg_quality = 75;
          let ofmt = match fmt {
              ImageFormat::Png if !exceeds_max_bytes => ImageOutputFormat::Png,
              ImageFormat::Jpeg => {
                  add_white_bg = false;
                  ImageOutputFormat::Jpeg {
                      quality: jpeg_quality,
                  }
              }
              _ => ImageOutputFormat::Jpeg {
                  quality: jpeg_quality,

An argument why they might have choosen this can probably be found in this comment:

github.com/chatmail/core

src/blob.rs

3c5af7a55


      
          if do_scale {
              loop {
                  if mem::take(&mut add_white_bg) {
                      self::add_white_bg(&mut img);
                  }
          
                  // resize() results in often slightly better quality,
                  // however, comes at high price of being 4+ times slower than thumbnail().
                  // for a typical camera image that is sent, this may be a change from "instant" (500ms) to "long time waiting" (3s).
                  // as we do not have recoding in background while chat has already a preview,
                  // we vote for speed.
                  // exception is the avatar image: this is far more often sent than recoded,
                  // usually has less pixels by cropping, UI that needs to wait anyways,
                  // and also benefits from slightly better (5%) encoding of Triangle-filtered images.
                  let new_img = if is_avatar {
                      img.resize(target_wh, target_wh, image::imageops::FilterType::Triangle)
                  } else {
                      img.thumbnail(target_wh, target_wh)
                  };
          
                  if encoded_img_exceeds_bytes(

So for now I don’t expect a “quick fix” by the devs because they would have to adapt the core library for that.