Nope, not just FSF. The Chromium team have prototyped JXL, but removed it initially for unknown reasons (https://bugs.chromium.org/p/chromium/issues/detail?id=117805...). Engineering teams including but not limited to Adobe, Facebook, Intel and Shopify have complained about its abrupt removal. Chromium developers have subsequently said that it was "due to low interest" (despite piles of messages from engineering teams both in leading companies and small groups saying otherwise).
> I cannot see how fair competition could require Google to be the first one to support a standard that literally nobody else supports.
First, Adobe products have just included JXL. Second, It's because Google is pushing for AVIF, which was extended from AV1. While it has some advantages (as essentially extended version from AV1), it also has a lot of disaadvantages: https://news.ycombinator.com/item?id=35590516. No one said to remove AVIF in favor of JXL but instead to support JXL regardless of Google's support of AVIF, and some people have seen it as forcing Google-favored AVIF instead of considering all formats developed (like how WebP was rammed a decade ago).
Just an FYI, they gave their reasons in comment #84 of the thread you linked.
E.g. Android TV now requires hardware support for AV1 [1] and Google threatened Roku that Rouku would lose Youtube support if it didn't support AV1 in hardware [2]
[1] https://www.protocol.com/bulletins/av1-android-14-requiremen...
Or they could pick a better format and evaluate it? The question is why the better format here, even though it is the same royalty free ( or patents free in AOM's term ), wasn't picked.
They’re a private company. They can choose to do whatever they want or don’t want to.
If they don’t want to support JPEGXL, why should they be forced to do it? If it was such a necessary format, it would have been a competitive disadvantage to not have support and that would have forced their hand, but nobody else supports it either so why should Google be forced to if they (clearly) don’t want to.
Found this: https://stackoverflow.com/questions/75459594/why-doesnt-edge...
Not sure what you mean by OS. The link you provided shows that Linux with several GNOME and other tools support JPEG-XL (especially GIMP).
Is this a good argument? Nobody is going to adopt something without being natively supported by browsers without ugly js hacks, and when it comes to browser standards it seems to me Google has more leverage than anybody else. Cloudinary has made a lot of posts about JPEG-XL, so you might say they're quite biased towards it, but it also seems to me there is some interest in it by multiple companies [0, 1]. I personally very much doubt webp would be anywhere today without the massive (arguably deceptive) campaigning and double standards it had.
0. https://en.wikipedia.org/wiki/JPEG_XL#Industry_support_and_a...
1. https://bugs.chromium.org/p/chromium/issues/detail?id=117805...
That's fair, but it is worth pointing out that <picture> tags support multiple source formats. I serve some logos and other important images as both .png and .webp. Adding additional lines for avif for jxl seem reasonable - especially if browsers are testing new formats.
Apple did not support JPEG XL, based on past history was unlikely to do so, and despite what you say about Google having the most leverage they have none on Apple. If Apple doesn't want something supported, no iOS browser will support it. And if no iOS browser supports a format, it is not going to be useful in production.
I do find it hilarious that all the people who complained about Chrome supporting webp then went on to complain about Chrome not supporting JPEG XL. They're both Google-created formats not widely supported by the ecosystem!
graphics heavy sites often optimize for various platforms instead of serving to just one standard.
What's the "conflict of interest" you're talking about? AVIF? How is that their own format when JPEG XL isn't?
If Apple, Mozilla and Microsoft wanted JPEG XL and committed to supporting it, I bet Chrome could be convinced to restore the support. But AFAIK those companies have made no such commitment, or even any kind of indication of intent. Why should we have another image format that gets only implemented in Chrome, not the wider web ecosystem? (Of course, they too are members of the foundation building AVIF. Oh my God, so many conflicts of interest!)
Google Research. Which is similar to Microsoft Research.
https://github.com/mozilla/standards-positions/issues/522#is...
They are different formats with different attributes, so it's reasonable to distinguish between them. JPEG XL is a general purpose image format. It's reasonable to want browsers to display it. WebP and AVIF are special-purpose formats, designed to leverage their corresponding video decoders, for delivery of ephemeral images to end-user devices. It's reasonable to object to limited formats that are manifestly crowding out general ones.
How is it Google created?
That's not to say they're the only contributors or should have all the credit. But it does make the "Google is trying to kill an open standard to push their own format" narrative here completely moronic.
The same company that gave us WebP. At least Mozilla and Safari did the sane thing and push back against it.
JPEG XL is a general purpose image format, like JPEG and PNG. WebP has one specific purpose: web delivery of ephemeral images, leveraging VP8 hardware decoding driven by consumer consumption devices. Google, and web-oriented companies in general, have no particular interest in general purpose image formats.
It is not the case for video. Video is still a huge bandwidth hog, and finding better codecs is worth it, that's why they get better support. Webp is a clever hack as it is essentially a single frame webm video, so if you have webm support, which is worth it, then you can have webp almost for free, JPEG-XL doesn't have that incentive.
JPEG = I want to see the content in the image but don't care too much about the quality
PNG = I want a lossless version of this image
Since bandwidth is cheap in most places, the only advantage that JPEG XL has is suddenly not that enticing.
I was trying to set the desktop background image on a project laptop last week. I found an image I liked, that would immediately remind me what machine this was when I look at it.
It was an AVIF. Windows 10 won't accept those as desktop backgrounds. It looked, for all intents and purposes, like the search image results were going to give me JPEGs -- the URL ended in .JPG and had "jpeg" as the media type! -- but that is not what I got. This did not work. Refusing to give up, I eventually determined that using curl to retrieve the image gave me a usable JPEG, and so I got my background and now I can tell this stupid project laptop apart.
For my use cases, which is as someone who does light work with images (backgrounds, occasional use in some kind of paint program, occasional insertion into documents or slides), anything that isn't a JPEG or PNG is actively harmful. Not everyone uses images the way I do, but developers need to remember that not everyone is a passive sheep who just stares at things or a power-developer who builds JPEG-XL from source in their sleep. There are people in between, and we don't take kindly to being forgotten.
Face it, these "modern" image formats are a massive annoyance for everyone except Web engineers.
I can't really imagine a world where you don't have to choose what format files should be in, and I can't really imagine a more easy way to do that conversion.
Making an image your wallpaper isn't something people do every day, going through an extra step is hardly onerous. And support will increase until it no longer matters.
1) Chrome is much bigger, so it's much more consequential, so it's valid is a bigger target for criticism
2) It's much easier to performantly support the format on some OS without it being "native", so again, lack of browser support is worse, and thus it's valid it's a bigger target for criticism
This is kinda how standards are supposed to work: at least two independednt implementations [1], released behind a flag to gather developer and user feedback. However it seems that in the end it went nowhere.
[1] See Implementation experience: https://www.w3.org/2021/Process-20211102/#implementation-exp... Among other considerations: "are there independent interoperable implementations of the current specification?"
How are you supposed to get feedback for a feature people can't actually use?
It's like when Debian removed a package I use that was not shipped under the rationale that "no one uses it". Obviously no one uses it - you never actually shipped it, you just had the source available if people wanted to compile it.
The moment it's out there (that is, not behind a flag), you cannot fix it, update it etc. because people will be relying on the observed behaviour.
The hard part is advertising the feature (at the very least to developers) because there are just too many featurs in modern browsers. Edit: for example, Chrome has Origin Trials https://developer.chrome.com/origintrials/#/trials/active for experimental features.
But you do it quickly, within a short time of launching it. Anyone who was able to make use of it within a couple months, will be able to adapt and fix things.
Once it's been there for a year, then sure, people rely on it. But there's no reason to take so long.
No, you can't. Not simply.
> But you do it quickly, within a short time of launching it. Anyone who was able to make use of it within a couple months, will be able to adapt and fix things.
That's not how the web works. "People who make use of it in a few months" could easily apps and sites serving millions of people. This is a process that applies not only to image codecs, but to, say hardware APIs and interfaces, network protocols etc.
> But there's no reason to take so long.
There are very many reasons from technical to political to anything in between (and sideways, too).
Or, if it's not behind a flag, then you can tell people not to use it, but they will anyway, which is exactly what you want, because then you get feedback. And when you change it, nothing really bad happens.
Sounds like the flag method is a failure, and just releasing it actually works.
In JPEG XL case it failed not because it was behind a flag, and the failure of one feature doesn't mean that the entire system isn't working.
> Sounds like the flag method is a failure, and just releasing it actually works.
No, "just releasing" doesn't work for the reasons I outlined above.
If a browser doesn't support a format as default nobody will use it unless big players like Apple or Google enforce it.
If Jpeg XL had been enabled some time without a flag they could claim > There is not enough interest from the entire ecosystem to continue experimenting with JPEG XL
but hidden behind a flag there is no way to know.
How many users enable experimental features in their browser?
Chrome added support for the in-progress version of JPEG XL in April 2021. The core coding specification was finished in March 2022, and the last part of the spec wasn't done until October 2022.
Chrome removed it in December 2022, citing a "lack of interest from the ecosystem", despite it having support in most major image editors already. It was a new format which was rapidly being adopted and a lot of major players were very excited about it, but Chrome's removal pretty much killed it due to their dominance in the browser space. At the time of removal, it had better support than HEIC!
I don't think I've ever encountered a single JPEG-XL image. Meanwhile I've encountered plenty of HEIC and never encountered a problem in dealing with them.
What annoys me more is that despite basically the entire modern tech industry being in support of- and pushing av1, 99% of the most-modern-compression content I encounter is encoded with h265. There's a good reason for it (h265's initial release was about 5 years earlier) but it still annoys me.
I was hoping at least av2 (or whatever it will be called) would be able to get ahead of h266, but I don't see that happening anymore either. Which means were gonna be stuck in the patents quagmire for a long while.
Even worse is that parties outside of AOmedia have created an av1 patent pool, despite the explicit reason for av1 being concocted is to not be patent encumbered. Most nastily, they don't go after AOmedia itself but instead sue small(er) parties using av1 to bully them into paying a license. One would expect AOmedia to bring to bear the full brunt of their collective legal departments to scare off the av1 patent leeches, but, so far, not a peep.
I find it frustrating how computers have gained so much compute and storage capacity but the web seems to be slipping away as ever more consumer-focused and neutered. Having been there since the beginning, I really expected the web tech and browsers to improve and facilitate scientific data sharing. Not being able to natively decode and display any "exotic" imagery without a bunch of server-side nonsense is frustrating.
Today's client machines have so much capability but become totally balkanized when you can't just serve an image tag and display a real scientific image. Instead you either have to hope the users install extra "workstation" tools to display an image after downloading, or deploy absurdly over-engineered "image servers" to do the basic image rendering and ship plain 8-bit JPEGs to the client.
Why can't a browser natively provide some basic range-mapping color transfer function tools for high bit-depth images in an image tag? Why can't it provide a pan-zoom viewing mode for high resolution images in an image tag?
Because on the web Google is 'the industry'. It's not a problem that it was behind a flag, it's a new format after all.
The problem is Google did implement it and then removed support without sufficient explanation. Given their market power and the fact they're behind competing standard, it raises a few questions.
https://caniuse.com/jpegxl
Unless I'm misunderstanding that, no browser actually ever supported JPEG-XL without a flag (or at all on Safari's cases). No OS appears to have supported it natively either[0]. The reality is that formats have a chicken & egg problem. Normally Google deserves to get dunked on, but in this case, why is Google the scapegoat instead of the entire industry that didn't adopt it? Feels like there is a bigger issue with JPEG-XL's failure to launch, and they did more than some (Apple? Microsoft?).
[0] https://en.wikipedia.org/wiki/JPEG_XL#Industry_support_and_a...