6 ms·
Why JPEG XL ignoring bit depth is genius (and why AVIF can't pull it off)
- kiicia 1y agojpeg xl is fantastic, yet autocratic google wants to force inferior format
- homebrewer 1y agoMozilla also isn't interested in supporting it, it's not just Google. I also often see these articles that tout jpeg-xl's technical advantages, but in my subjective testing with image sizes you would typically see on the web, avif wins every single time. It not only produces fewer artifacts on medium-to-heavily compressed images, but they're also less annoying: minor detail loss and smoothing compared to jpeg-xl's blocking and ringing (in addition to detail loss; basically the same types of artifacts as with the old jpeg). Maybe there's a reason they're not bothering with supporting xl besides misplaced priorities or laziness.
- deleted 1y ago[deleted]
- Retric 1y agoJPEG-XL is optimized for the low to zero levels of compression which isn’t as commonly used on the web, but definitely fills a need. Google citied insufficient improvements which is a rather ambiguous statement. Mozilla seems more concerned with the attack surface.
- formerly_proven 1y agoJPEG XL seems optimally suited for media and archival purposes and of course this is something you’d want to mostly do through webapps nowadays. Even relatively basic uses cases like Wiki Commons is basically stuck on JPEG for these purposes. For the same reason it would be good if a future revision of PDF/A would include JPEG XL, since it doesn't really have any decent codecs for low-loss (but not losless) compression (e.g. JPEG sucks at color schematics/drawings and losless is impractically big for them). It did get JP2 but support for that is quite uncommon.
- OneDeuxTriSeiGo 1y ago> Mozilla also isn't interested in supporting it Mozilla is more than willing to adopt it. They just won't adopt the C++ implementation. They've already put into writing that they're considering adopting it when the rust implementation is production ready. https://github.com/mozilla/standards-positions/pull/1064 https://github.com/mozilla/standards-positions/pull/1064
- masklinn 1y agoYou have a really strange interpretation of the word “consider”.
- mistercow 1y agoSeems like the normal usage to me. The post above lists other criteria that have to be satisfied, beyond just being a Rust implementation. That would be the consideration.
- masklinn 1y agoMozilla indicates that they are willing to consider it given various prerequisite. GP translates that to being “more than willing to adopt it”. That is very much not a normal interpretation.
- OneDeuxTriSeiGo 1y agoFrom the link > To address this concern, the team at Google has agreed to apply their subject matter expertise to build a safe, performant, compact, and compatible JPEG-XL decoder in Rust, and integrate this decoder into Firefox. If they successfully contribute an implementation that satisfies these properties and meets our normal production requirements, we would ship it. That is a perfectly clear position.
- deskamess 1y agoHow far away is JPEG-XL rust version from Google if Chrome is not interested in it?
- demetris 1y agoI did some reading recently, for a benchmark I was setting up, to try and understand what the situation is. It seems things have started changing in the last year or so. Some links from my notes: https://www.phoronix.com/news/Mozilla-Interest-JPEG-XL-Rust https://www.phoronix.com/news/Mozilla-Interest-JPEG-XL-Rust https://news.ycombinator.com/item?id=41443336 https://news.ycombinator.com/item?id=41443336 (discussion of the same GitHub comment as in the Phoronix site) https://github.com/tirr-c/jxl-oxide https://github.com/tirr-c/jxl-oxide https://bugzilla.mozilla.org/show_bug.cgi?id=1986393 https://bugzilla.mozilla.org/show_bug.cgi?id=1986393 (land initial jpegxl rust code pref disabled) In case anyone is curious, here is the benchmark I did my reading for: https://op111.net/posts/2025/10/png-and-modern-formats-lossless-image-compression/ https://op111.net/posts/2025/10/png-and-modern-formats-lossl...
- idoubtit 1y agoNo, the situation about image compression has not changed. The Grand Poster you were replying to was writing about typical web usage, that is "medium-to-heavily compressed images", while your benchmark is about lossless compression. BTW, I don't see how Mozilla's interest in a jpegxl _decoder_ (your first link) has anything to do with the performance of jpegxl encoders compared to avif's encoders. In case you're really interested in the former, Firefox now has more than intentions, but it's still not at production level: https://bugzilla.mozilla.org/show_bug.cgi?id=1986393 https://bugzilla.mozilla.org/show_bug.cgi?id=1986393
- demetris 1y agoNo. demetris’ benchmark of lossless image compression is not a sign that the situation may be changing. :-D That was just the context for some reading I did to understand where we are now. > BTW, I don't see how Mozilla's interest in a jpegxl _decoder_ (your first link) has anything to do with the performance of jpegxl encoders compared to avif's encoders. In case you're really interested in the former, Firefox now has more than intentions, but it's still not at production level: https://bugzilla.mozilla.org/show_bug.cgi?id=1986393 https://bugzilla.mozilla.org/show_bug.cgi?id=1986393 That is one of the links I shared in my comment (along with the bug title in parenthesis). :-)
- gcr 1y agoI've had exactly the opposite outcome with AVIF vs JPEG-XL. I've found that jxl outperforms AVIF quite dramatically at low bitrates.
- miladyincontrol 1y agoSame in my experience testing and deploying a few sites that support both. In general the only time AVIF outperformed in file size for me was with laughably low quality settings beyond what any typical user or platform would choose. And for larger files especially the benefits of actually having progressive decoding, pushed me even more in favour of jpeg-xl. Doubly so when you can just provide variations in image size by halting the bit flow arbitrarily.
- ksec 1y ago>but in my subjective testing with image sizes you would typically see on the web, avif wins every single time. What is that in terms of bpp? Because according to Google Chrome 80-85% of we deliver images with bpp of 1.0 or above. I don't think most people realise that. And in most if not all circumstances, jpeg XL performs better than AVIF at bpp 1.0 and above tested by professionals.
- AlienRobot 1y agoI wish they separated the lossless codec into "WebPNG." WebP is better than PNG, but it's too risky to use (and tell people to use) a lossless format that is lossy if you forget to use a setting.
- est 1y ago> JPEG XL’s Radical Solution: Float32 + Perceptual Intent So 2^32 bit depth? 4 bytes seems an overkill.
- fps-hero 1y agoDid you miss the point of the article? JPEG-XL encoding doesn't rely on quantisation to achieve its performance goals. Its a bit like how GPU shaders use floating point arithmetic internally but output quantised values for the bit depth of the screen.
- est 1y ago> Did you miss the point of the article? Sorry I missed. How is the "floating point" stored in .jxl files? Float32 has to be serialized one way or another per pixel, no?
- jstanley 1y agoNo, JPEG is not a bitmap format.
- wongarsu 1y agoThe cliff notes version is that JPEG and JPEG XL don't encode pixel values, they encode the discrete cosine transform (like a Fourier transform) of the 2d pixel grid. So what's really stored is more like the frequency and amplitude of change of pixels than individual pixel values, and the compression comes from the insight that some combinations of frequency and amplitude of color change are much more perceptible than others
- tetris11 1y agoThe gradient is stored, not the points on the gradient
- jlouis 1y agoIn addition to the other comments: you can have an internal memory representation of data be Float32, but on disk, this is encoded through some form of entropy encoding. Typically, some of the earlier steps is preparation for the entropy-encoder: you make the data more amenable to entropy-encoding through rearrangement that's either fully reversible (lossless), or near-reversible (lossy).
- diffuse_l 1y agoI think the article could be better and get the point across with half the length and without the second half of it being full of ai generated list of advantages, or using that space to give some more technical information
- evertedsphere 1y agothe article could be better if it weren't entirely "ai generated"
- diffuse_l 1y agoWell, at least the first half was somewhat useful...
- Gigachad 1y agoMaybe we can AI summarise it back to the original prompt to save time.
- cainxinth 1y ago> Write a short article explaining that JPEG XL's genius is its bit-depth-agnostic design, which converts all image data into a perceptually-based floating-point format (XYB) to optimize compression for what the human eye actually sees. In contrast, AVIF is locked into its video-codec legacy, forcing it to use rigid, integer-based bit-depth modes that optimize for numerical precision rather than true perceptual quality.
- Lanedo 1y ago> Find the (minimal) AI prompt that lead to the generation of this article: [...] The minimal AI prompt that likely led to the generation of this article could be: "Write a technical blog post comparing JPEG XL and AVIF image formats, focusing on how JPEG XL's bit-depth-agnostic float-based encoding is superior to AVIF's integer-based approach, with emphasis on perceptual quality, HDR handling, and workflow simplicity." This prompt captures the core elements: - Technical comparison between two image formats - Focus on JPEG XL's unique "ignoring bit depth" design - Emphasis on perceptual vs. numerical quality - Discussion of HDR and workflow benefits - Tone and structure matching the published article The prompt would have guided the AI to produce content that: 1. Explains the technical difference in encoding approaches 2. Demonstrates why JPEG XL's method is better 3. Provides real-world implications for users 4. Maintains the author's voice and technical depth 5. Follows the article's structure and emphasis on "perceptual intent" over bit precision
- zokier 1y agoWorking with single fixed bit depth is imho different than being bit-depth agnostic. Same argument could be made about color spaces too.
- WithinReason 1y agoYes, this is great, but why don't we make the same argument for resolution too? I think we should!
- shiandow 1y agoI completely agree. Based on my limited experience with image upscaling, downscaling, and superresolution, saving video at a lower resolution is the second crudest way of reducing the file size. The crudest is downsampling the chroma channel, which makes no sense whatsoever for digital formats.
- colonwqbang 1y agoSo they "ignore" bit depth by using 32 bits for each sample. This may be a good solution but it's not really magic. They just allocated many more bits than other codecs were willing to. It also seems like a very CPU-centric design choice. If you implement a hardware en/decoder, you will see a stark difference in cost between one which works on 8/10 vs 32 bits. Maybe this is motivated by the intended use cases for JPEG XL? Or maybe I've missed the point of what JPEG XL is?
- adgjlsfhk1 1y agoimage decoding is fast enough that no one uses hardware encoders. The extra bits are very cheap on both CPU and GPU, and by using them internally, you prevent internal calculations from accumulating error, and end up with a much cleaner size quality trade-off. (note that 10 bit output is still valuable on an 8 bit display because it lets the display manager dither the image
- colonwqbang 1y agoThat is true! But AVIF is based on AV1. As a video codec, AV1 often does need to be implemented in dedicated hardware for cost and power efficiency reasons. I think the article is misleading in this regard: "This limitation comes from early digital video systems". No, it is very much a limitation for video systems in the current age too.
- fleabitdev 1y agoInteresting approach. It doesn't even introduce an extra rounding error, because converting from 32-bit XYB to RGB should be similar to converting from 8-bit YUV to RGB. However, when decoding an 8-bit-quality image as 10-bit or 12-bit, won't this strategy just fill the two least significant bits with noise?
- shiandow 1y agoCould be noise, but finding a smooth image that rounds to a good enough approximation of the original is quite useful. If you see a video player talk about debanding it is a exactly that. I don't know if JPEG XL constrains solutions to be smooth.
- adgjlsfhk1 1y agoI believe they constrain to piecewise smooth (i.e. don't smooth out edges but do smooth out nose)
- TechRemarker 1y agoWhen exporting images from Lightroom Classic in JPEX XL you can choose the percent of compress or choose lossless which disable that of course. But also default to 8bit, but an option for 16bit which of course results in a much larger file. And color profile setting. So curious what they mean by it ignores bit depth? Did some sample exports comparing JXL 8bit lossless vs JPG and JXL was quite a bit bigger. Same for doing lossy 100 comparison or 99 comparison of both. When setting JXL to 80%, 70% see noticeably savings but had thought the idea was JXL full quality essentially for much smaller sizes. To be fair the 70% does look very similar to 100% but then again the JPEG 70% vs 100% also look very similar on an Apple XDR Monitor. the 70% or 80% etc on both jpeg and jpeg xl i do see visual differences in areas like on shoes where there is mesh. JXL comes with lots of compatibility challenges since while things were picking up with Apple's adoption it seems to have halted since and apps like Evoto, and Topaz not adding support among many others. And Apple's still not full support and no progress on that. So unless Chrome does a 180 again, think AVIF and JXL will both end up stagnating and most sticking with JPG. For Tiff though noticed significant savings lossless jxl compared to tiff so that would be a good use case except tiffs more likely ones to be edited by third party apps that most likely won't support the format.
- jonsneyers 1y agoFor lossless, bitdepth of course does matter. Lossless image compression is storing a 2D array of integer numbers exactly, and with higher bitdepth, the range of those numbers grows (and the amount of hard-to-compress least significant bits grows). The OP article is talking about lossy compression. When comparing lossy compression, note that lossy compression settings are not a "percent" of anything, it's just an arbitrary scale that depends on the encoder implementation. So lossy "80%" is certainly not the same thing between JPEG and JXL, or between Photoshop and ImageMagick, etc. It's not a percentage of anything — it's just an arbitrary scale that gets mapped to encoder parameters (e.g. quantization tables) in some arbitrary way. The best way to compare lossy compression performance is to encode an image at the quality that is acceptable for your use case (according to your eyes), and then you just look for various codecs/encoders what the lowest filesize is you can get while still getting an acceptable quality.
- JyrkiAlakuijala 11mo agoThe original JPEG XL requirements were relational colors, where colors are an issue external to the codec. I was able to sufficiently convince the rest of the jpeg committee that we can achieve similar interoperability with absolute color, and particularly my xyb color space, and the absolute color storage giving us more opportunity to psychovisual optimization. Also, I was behind not having 8, 10, 12 bit modes, but just a single mode, and always yuv444 — to simplify operation and creating less confusion and less hard additional quality boundaries. Some of this "beauty" such as no yuv420 we needed to backtrack from for adding the lossless jpeg1 recompression support.