Mozilla Research

For the downstream side Mozilla has done some great progress with CRLite, which I think hasn't gotten enough attention. https://youtube.com/watch?v=gnB76DQI1GE&t=19517s https://research.mozilla.org/files/2025/04/clubcards_for_the_webpki.pd…

For what it's worth, I did try this out. Downloaded the little Bing desktop enforcement app and everything. Also on the phone. Signed in on both. Returned to the 'access' faster page. Nope, just same old 'Do this process to get it faster!'. So it was completely pointless. Unless they mean, jump the queue, and it's in a couple days? But it doesn't _say_ that really. So I dislike this little thing they pulled here. It could be biased too, as I was recently reading about this: Five Walled Gardens: Why Browsers are Essential to the Internet and How Operating Systems Are Holding Them Back. https://research.mozilla.org/files/2022/10/Mozilla-Five-Walled-Gardens…

For dynamic languages sure. For strongly typed languages it's better to just use the type system to prevent those kind of things. C++ doesn't have great support here (lots of boilerplate needed) & usually people reach for Boost Units or Boost strong types but it's not that hard (https://www.fluentcpp.com/2016/12/08/strong-types-for-strong-interface… Mozilla is also exploring this specifically for coordinate spaces & whatnot too (https://research.mozilla.org/2014/06/23/static-checking-of-units-in-se…

To counter this, Firefox is the only desktop browser that supports VR out of the box. In fact, Mozilla has an entire team dedicated to emerging technologies[0] and you can see what that team is focusing on on their website. [0] https://research.mozilla.org/ Disclaimer: Associated with Mozilla (Foundation), not Firefox (Mozilla Corporation).

Mozilla did release DeepSpeech[0] and Firefox Translation[1] (the latter of which they included in Firefox, to offer client-side webpage translations.) They definitely have fewer resources than OpenAI, and they do not produce SOTA research (their publications have plummeted to 1/year anyway[2]). So the only way for them to make progress is to seek government grants or make challenges like these. This challenge is unlikely to be profitable for the winning team: the expected value of winnings are likely around $1K when taking into account the probability that another team gets a better rank, but ML research projects are often more expensive (recently, Alpaca spent upwards of $600 on computation alone; and of course pretraining large models is much more expensive). So the main gain will be publicity. [0]: https://github.com/mozilla/deepspeech [1]: https://github.com/mozilla/firefox-translations/ [2]: https://research.mozilla.org/

This article like many others is full of fallacies. Image formats are not used wisely: [1] is PNG not JPEG and [2] is JPEG not PNG. > I found that setting quality (mozjpeg) to 70 produces good enough images for the most part, but your mileage may vary. You can get away with this setting for hidpi sizes but 1x will look horrible [1]. If you care about quality, the mileage is actually 75-95. > (Pngquant) quality level of 65-80 to provide a good compromise between file size and image quality Again, it may only be applied to hidpi sizes, and it will easily ruin any gradients or previously quantized images. Pngquant is a great color quantization tool but it does not actually perform any lossless PNG optimizations, which can save you at least 5% more, and up to 90% in some cases. All of these tools will also blindly strip metadata (but it's not guaranteed!) along with color profiles and Exif Orientation resulting in color shifts and image transformations respectively. Most importantly, none of them are good enough for automatic lossy compression. Guetzli is the closest but it still has some severe issues [3]. I'm also trying to build a real thing, and it is hard. > there’s value in using WebP formats where possible WebP lossless and WebP lossy are quite different formats. WebP lossy being always 4:2:0 is not a good replacement for JPEG [4] especially at higher quality. On the contrary WebP lossless has evolved into a decent alternative for PNG including lossy…

Actual Mozilla page: https://research.mozilla.org/browser-competition/over-the-edge-the-use…

They did. https://research.mozilla.org/browser-competition/5wg/

Here's the actual report, maybe better to link to that? https://research.mozilla.org/files/2024/01/Over-the-Edge-Report-Januar…

From my own experience, JPEG quality and compression efficiency can differ a lot depending on the encoder implementation. It would make more sense to compare specific encoders rather than formats in general. In 2014 (WebP was released in 2010) Mozilla claimed that the standard JPEG format is not used to it's full potential [1] and introduced mozjpeg project that is still being updated [2]. I wonder how it compares today with current WebP implementations. [1] https://research.mozilla.org/2014/03/05/introducing-the-mozjpeg-projec… [2] https://github.com/mozilla/mozjpeg

This should be a wake-up call to people that we need a new operating system https://research.mozilla.org/files/2022/10/Mozilla-Five-Walled-Gardens…

Firefox didn't add Webp support for a long time, because it wasn't a massive, massive improvement over the existing image formats. https://research.mozilla.org/2013/10/17/studying-lossy-image-compressi… More recent coverage: https://siipo.la/blog/is-webp-really-better-than-jpeg

This article is centered around a report from Mozilla without actually linking to it... Here is the original report https://research.mozilla.org/browser-competition/

Off the top of my head… Firecracker, the software AWS Lambda runs on, is written in Rust: https://github.com/firecracker-microvm/firecracker Mozilla wrote Servo, a browser engine, in Rust. Part of it has been integrated into Firefox a while ago: > Mozilla incorporated the Servo CSS Style engine in release 57 of its Firefox Quantum browser. https://research.mozilla.org/servo-engines/ It’ll be used in Android: https://security.googleblog.com/2021/04/rust-in-android-platform.html?… It’ll probably find it’s way into the Linux kernel: https://news.ycombinator.com/item?id=29485465

In what way? Rust seems to be proving itself as a reliable mainstay in systems development https://github.com/rust-lang/rust The git repo has over 150,000 commits, 3,000 contributors, and 9 years of release history. The last 6 years of which have been post 1.0. Also, Mozilla has been writing large parts of firefox in Rust since ~2017. There's some interesting writeups on hacks.mozilla, including this one on reducing CVEs with Rust https://hacks.mozilla.org/2019/02/rewriting-a-browser-component-in-rus… https://research.mozilla.org/rust/

Fat chance. It doesn't implement any CSS selectors at all. Servo passed Acid2 in 2014: https://research.mozilla.org/2014/04/17/another-big-milestone-for-serv… This is really far behind.

Servo has JavaScript own and collect the DOM nodes. At least, it did in 2014. https://research.mozilla.org/2014/08/26/javascript-servos-only-garbage…

> Mozilla has shipped successful products other than Firefox. Rust being a strong example Isn't Rust a language? https://research.mozilla.org/rust/ How is that going to keep the lights on? Doesn't seem like it contributes to the bottom line in any way, so they would have been better off allocating those people to keeping Firefox competitive. Seems like they need a "more wood behind fewer arrows" moment like Google had. Or a "sell everything but consulting" since consulting is the only thing making money moment like IBM had when they sold laptop, storage, printer, etc. divisions.

Put another way: The video patent cartels have fragmented due to greed, and so the cartel enablers at ISO have lost their purpose. In addition, organizations are tired of paying bridge tolls. So we can finally have open standards for video that anyone can just use and implement. AV1 in particular seems to be on its way to replacing them: https://research.mozilla.org/av1-media-codecs/

Rust is not a Mozilla project, but it is sponsored by Mozilla. https://research.mozilla.org/rust/

Servo is not a browser, it is a browser engine. To quote the Mozilla Research page about it: "Like WebKit, the Servo project is not a complete browser. It is an experimental project that delivers components that can load, run, and display web sites and applications." Given that, it doesn't make sense to talk about users "…switching from Firefox to Servo." c.f. https://research.mozilla.org/servo-engines/

What do you suggest Mozilla do instead? Mozilla don't just fund the development of their own products they also fund research [1] and other projects [2]. [1] https://research.mozilla.org/research-grants/ [2] https://www.mozilla.org/en-US/grants/ In a perfect world Mozilla would be funded by donations. I donate to Mozilla but it's a pittance compared to what they get from Google.

Mozilla Deepspeech (Speech tp Text) and Mozilla TTS are both useful at this point: https://research.mozilla.org/machine-learning/

I don't know about 'authoritative', but ads do seem to hurt. The existing experimental and quasi-experimental literature shows very bad effects on user behavior: 1. "Measuring Consumer Sensitivity to Audio Advertising: A Field Experiment on Pandora Internet Radio", Huang et al 2018: https://davidreiley.com/papers/PandoraListenerDemandCurve.pdf [experimental] 2."The Effect of Ad Blocking on [Firefox] User Engagement with the Web", Miroglio et al 2018: https://research.mozilla.org/files/2018/04/The-Effect-of-Ad-Blocking-o… [quasi] 3. and my own A/B test: https://www.gwern.net/Ads [experimental]

While it may not be an explicit goal, everything I’ve read implies that, for example the heading in this wiki on oxidization: https://wiki.mozilla.org/Oxidation > Moving forward, the goal of Oxidation is to make it easier and more pleasant to use Rust in Firefox, and correspondingly to increase the amount of Rust code in Firefox. And then there is the Rust page on Mozilla’s site: > Mozilla also utilizes Rust in many of its core initiatives including Servo and key parts of Firefox. https://research.mozilla.org/rust/ Where “key parts” is a link to the project quantum announcement: https://medium.com/mozilla-tech/a-quantum-leap-for-the-web-a3b7174b3c1… > Initially, Quantum will share a couple of components with Servo, but as the projects evolve we will experiment with adopting even more.

And that’s why you use Common Voice and Deep Speech from Mozilla. https://research.mozilla.org/machine-learning/

Hi, I'm a Servo developer who worked on some of the Rust code that's in Firefox. Calls between C++ and Rust code in Firefox all go through "extern C" functions. Some of the code involves reference-counted smart pointers. We use RAII wrapper types in both Rust and C++ to ensure that refcounts are incremented and decremented correctly on either side of the FFI boundary. P.S. This old blog post is not about Rust-in-Firefox, but it does cover a related topic: How the Servo browser engine (written in Rust) interacts with the Spidermonkey JavaScript engine (written in C++ and embedded in both Gecko and Servo), including garbage-collected JavaScript objects: https://research.mozilla.org/2014/08/26/javascript-servos-only-garbage…

Hm, are there any cases of two GC'd languages that interop well that were not designed to interop from day one (that is, JVM languages don't count)? The only one that comes to mind is https://research.mozilla.org/2014/08/26/javascript-servos-only-garbage… , which is Rust (pre-1.0) and JavaScript, but that somewhat doesn't count because Rust isn't really a GC'd language. (This article was written about a year after the special syntax for garbage-collected references was removed and Gc<T> became just a thing in the standard library, and about a month before that type was also removed because it wasn't a very good GC.) It seems to me that if you make your GC a purely refcounting system this is easier: you just need to specify how to incref and decref objects, and put a well-known function in the vtable for destroying and deallocating the object. I'd guess that's how things like GObject or Qt bindings in Python or similar languages work.

> The only big thing I can think of is the safety of compile-time type checking to ensure you won't end up with some kind of runtime error from mismatched types. Is there something I'm missing? It's this but designs in statically typed languages with more expressive type systems tend to push a lot of the logic into the type system so you can't use APIs incorrectly. This isn't exclusive to Rust but I do have a few examples: The Glium OpenGL wrapper puts a lot of effort into moving errors to compile time. The overview[1] explains a bunch of them. [1] https://github.com/glium/glium#why-should-i-use-glium-instead-of-raw-o… The Servo project uses the type system to tie rust code into the spidermonkey garbage collector so it can't be misused[2]. [2] https://research.mozilla.org/2014/08/26/javascript-servos-only-garbage… More abstractly, one of the more unique features of Rust's type system (linear types) is the ability to be sure a reference is destroyed. This makes Rust particularly good at describing state machines that are compile-time checked. Using standard OOP terms, each state is a class and its methods are the valid transitions. You can't take an invalid transition because the method is missing. You can do this in any language, though it tends to be only done in statically typed languages and it's awkward in Python. What makes Rust unique is that calling the method will consume the instance so you can't accidentally make a transition twice. Trying…

> There is no signal to developers that an implementation is flawed, and so mistakes can happen without being noticed. That is, until a new version of the protocol is deployed and your implementation fails, but by then the code is deployed and it could take years for everyone to upgrade. > If a protocol is designed with a flexible structure, but that flexibility is never used in practice, some implementation is going to assume it is constant. Perhaps this is a naive thought. I remember several years ago Mozilla announced its experimental browser rendering engine (Servo) passed Acid 2 tests [1]. So why can't we come together and create such standard tests so that server implementers and middlebox implementers are encouraged to include them as part of their QA score? I know this is an optional. There is no mandate, but it sounds like a start. Isn't there some network vendor organization the major players are part of? [1]: https://research.mozilla.org/2014/04/17/another-big-milestone-for-serv…