News for hackers. Stuff that matters.
Re:Revisiting how we build Firefox by joshmoz on Monday July 06, 2015 @01:56PM (#9840923)
Some context that might help people understand this email...

There are two high-level components which make up Firefox. The first is Gecko, the rendering engine. The second is Firefox, the application itself, which uses Gecko to render Web pages and itself.

Firefox, built on top of Gecko, is written primarily in XUL and XBL (and JS).

https://en.wikipedia.org/wiki/XUL https://en.wikipedia.org/wiki/XBL

What's going on here is that Mozilla is considering getting rid of XUL and XBL and building Firefox with the same technologies that people use to build Web content.

There are at least three big advantages to doing this:

1. Eliminate the need to support XUL and XBL in Gecko.

2. Contributing to Firefox gets easier because there is no need to learn what are essentially Mozilla-specific languages.

3. Mozilla learns more about what it takes to build complex applications like Firefox itself using Web technologies.

The only real downside is the amount of work involved.

Re:Revisiting how we build Firefox by ykl on Monday July 06, 2015 @02:04PM (#9840969)
Could this potentially be a first step towards eventually replacing Gecko with Servo? If Firefox (the application itself) eventually resembles browser.html [1], swapping out Gecko for Servo would be much easier.

[1] https://github.com/mozilla/browser.html

Re:Revisiting how we build Firefox by campd on Monday July 06, 2015 @02:14PM (#9841027)
It's not not the first step.

That's not the primary driver of this plan. But it might be a happy side effect.

Servo is still in early stages, we aren't making product plans around it.

Re:Revisiting how we build Firefox by Roodgorf on Monday July 06, 2015 @03:16PM (#9841493)
If that were to happen, how big an impact would that have on Firefox OS development? I admittedly don't understand the project too well, but they had to port Gecko to work in Gonk right? Would there be significant overhead getting Servo working under Gonk?
Re:Revisiting how we build Firefox by fabrice_d on Monday July 06, 2015 @03:56PM (#9841782)
A few things:

- currently browser.html runs on top of a gecko runtime (called graphene) which is based on the one we use for FirefoxOS.

- getting gecko to work on gonk is not different from adding support for other platforms like linux/mac/windows/android. Basically you need to provide implementation for low level windowing and input events. On non-posix systems there's a bit more to do in the nspr library, but that's not the case for gonk.

- we already have a port of servo that runs on gonk.

FirefoxOS has been using a 100% html UI since about 4 years, so it has been leading the way here.

Re:Revisiting how we build Firefox by Roodgorf on Monday July 06, 2015 @04:59PM (#9842145)
Very cool, thanks for the information. I'm obviously more ignorant of Mozilla projects than I even thought.
Re:Revisiting how we build Firefox by Manishearth on Monday July 06, 2015 @05:10PM (#9842212)
It would certainly help us port Firefox to Servo. But that's never really been a part of the plan.

Gecko and Firefox are quite intertwined. Even if we ignore XUL/XBL, there are things like XPCOM which are still deep-rooted. While this brings us a step closer to making Servo a drop-in for Gecko, this is not a step in a direction we're particularly interested in. At least not now, not that I know of (I'm a volunteer on the Servo team, as such there may be internal plans I'm not aware of).

For Servo one potential way ahead is bringing browser.html up to Firefox's level. Not the other way around :)

Re:Revisiting how we build Firefox by dherman on Monday July 06, 2015 @07:29PM (#9842791)
I agree it doesn't make sense for Servo to be a drop-in replacement for Gecko, but that doesn't mean we shouldn't bend Firefox towards compatibility with Servo. A future Servo-based Firefox is far enough off that it's impossible to predict every step from here to there, but if you ask me, dcamp's email is on the right track: we should evolve Firefox away from dependence on non-standard tech like XUL, XBL, and XPCOM and towards self-hosting on standard web technology and taking full advantage of everything Servo has to offer. What that looks like in practice remains to be seen.
Re:Revisiting how we build Firefox by fabrice_d on Monday July 06, 2015 @07:50PM (#9842844)
I agree. A key point to achieve that is to define what the embedding api looks like. Right now on FirefoxOS it's partly the mozbrowser api for iframe-centric features, and partly custom events that are dispatched on the top level "chrome" iframe. There's still some cleanup to do there ;)
Re:Revisiting how we build Firefox by Manishearth on Tuesday July 07, 2015 @01:24AM (#9843772)
Of course. I'm just saying that from the point of view of Servo, drop-in Gecko isn't really the focus. Making Gecko more HTML-y is a great step for Gecko, but from a purely Servo point of view at the moment it's not really something tangible. Though you're right, it may mean something for Servo a couple of years from now.
Re:Revisiting how we build Firefox by piyush_soni on Monday July 06, 2015 @02:14PM (#9841025)
The only thing I'm worried about is how would it affect performance. Does it mean the UI itself would be rendered using Gecko Engine?
Re:Revisiting how we build Firefox by campd on Monday July 06, 2015 @02:19PM (#9841058)
Like pcwalton said, we already use Gecko to render the UI. But we're using a less well-optimized, less well-maintained corner of Gecko.

Improving performance is an explicit goal of this work.

Re:Revisiting how we build Firefox by joshmoz on Monday July 06, 2015 @02:21PM (#9841082)
The Firefox (Desktop) UI is already rendered using Gecko. It has been that way since the beginning.

Mozilla spends much more time optimizing HTML and other Web content tech than it does optimizing XUL and XBL. I wouldn't worry too much about this project slowing down Firefox. It might even speed it up a bit.

Re:Revisiting how we build Firefox by McElroy on Monday July 06, 2015 @02:24PM (#9841090)
The e-mail seems to suggest that it would improve performance.

>Because XUL and XBL aren’t web technologies, they don’t get the same platform attention that HTML does (for good reason!). Performance problems go unfixed and it creates a lot of unnecessary complexity within Gecko. It’s harder for even experienced web developers to get up to speed. It’s further from the web, and that doesn’t help anybody.

Re:Revisiting how we build Firefox by toyg on Monday July 06, 2015 @02:20PM (#9841073)
I believe that's already the case, although it uses XUL-specific code paths in Gecko.

In terms of performance -- there is no deep reason for it being slower, but of course the code might end up being a bit less optimized compared to stuff that has been battle-tested for 15 years. On the other hand, getting rid of XUL could deliver dramatic results. It's all speculation really, but there is no real technical reason for "XUL-less FF" to be incredibly slower than current offering.

Re:Revisiting how we build Firefox by brandonwamboldt on Monday July 06, 2015 @02:18PM (#9841055)
It already is. XUL is rendered via Gecko.
Re:Revisiting how we build Firefox by mburns on Monday July 06, 2015 @02:18PM (#9841051)
XUL is already rendered using Gecko.
Re:Revisiting how we build Firefox by pcwalton on Monday July 06, 2015 @02:17PM (#9841046)
It already is.
Re:Revisiting how we build Firefox by M2Ys4U on Monday July 06, 2015 @02:20PM (#9841066)
It already is, only the UI is written in XUL.
Re:Revisiting how we build Firefox by simcop2387 on Monday July 06, 2015 @02:00PM (#9840942)
Another advantage that's not immediately apparent is that it would also open up changing the rendering engine. I think the firefox mobile browser is actually using this to do the main UI on android at least. Along with that there's the browser.html that Servo is using as a base for the browser chrome.
Re:Revisiting how we build Firefox by kbrosnan on Monday July 06, 2015 @02:05PM (#9840982)
Firefox for Android is Gecko. Firefox for iOS which is in the works is playing inside the Apple ecosystem, using WebKit.
Re:Revisiting how we build Firefox by simcop2387 on Monday July 06, 2015 @02:13PM (#9841020)
I can't imagine that Firefox on iOS will actually be that useful. Half the usefulness of Firefox is the extensions which I think would violate the store rules on iOS wouldn't they?
Re:Revisiting how we build Firefox by danudey on Monday July 06, 2015 @02:18PM (#9841057)
The primary usefulness I would see is syncing your browser history, bookmarks, etc. across devices. I use Safari and I have pretty much every extension I feel like I need.
Re:Revisiting how we build Firefox by JadeNB on Monday July 06, 2015 @07:45PM (#9842829)
Can this be done? The last time I checked, Firefox Sync was only available on iOS via some hacky workaround with an extra (ToS-bending) app.
Re:Revisiting how we build Firefox by rfk on Monday July 06, 2015 @11:18PM (#9843457)
Yes, proper syncing with Desktop Firefox is a core part of the new Firefox for iOS initiative.
Re:Revisiting how we build Firefox by JadeNB on Monday July 06, 2015 @11:25PM (#9843480)
OK, but (sorry if I'm misunderstanding!) can it be done now?
Re:Revisiting how we build Firefox by rfk on Tuesday July 07, 2015 @12:40AM (#9843664)
Not sure I understand your question, but the thing I'm talking about is a new "Firefox for iOS" product being worked on right now, due for release pretty soon IIUC, that will include syncing among its core capabilities:

  https://github.com/mozilla/firefox-ios
Re:Revisiting how we build Firefox by malkia on Monday July 06, 2015 @04:36PM (#9842023)
I wonder if there could be some collaboration where firefox, chrome, safari, IE, opera, etc. can exchange and sync - possibly too much to deal with, and might hurt innovation.
Re:Revisiting how we build Firefox by addicted44 on Monday July 06, 2015 @05:01PM (#9842156)
Firefox is my primary browser everywhere but on iOS. It would be nice if I could have the passwords, history and bookmarks available to me on all my other OSes on iOS as well.

This is a huge gap for Firefox IMO.

Re:Revisiting how we build Firefox by nextos on Monday July 06, 2015 @03:05PM (#9841431)
Will this lead to loosing any of the flexibility in configuring Firefox (all variables you can find in about:config) that is so useful when using e.g. vimperator or pentadactyl?
Re:Revisiting how we build Firefox by rockdoe on Monday July 06, 2015 @03:49PM (#9841742)
I don't see any relation between the two.
Re:Revisiting how we build Firefox by skybrian on Monday July 06, 2015 @02:25PM (#9841103)
Wouldn't all Firefox plugins need to be rewritten?
Re:Revisiting how we build Firefox by clarkbw on Monday July 06, 2015 @03:42PM (#9841694)
Firefox add-ons that use the XUL overlay system would need to be written as SDK style add-ons.
Re:Revisiting how we build Firefox by JoshTriplett on Monday July 06, 2015 @06:31PM (#9842590)
Addons that use XUL would need a rewrite, but they already did, as Firefox Mobile doesn't support XUL.

(Plugins need to just go away, and they mostly have.)

Re:Revisiting how we build Firefox by Larrikin on Tuesday July 07, 2015 @12:49AM (#9843685)
Plugins are the only reason I use Firefox over any other browser.

Can you explain to me why Firefox would be better off if I didn't have Rikaisama for my Japanese studying or one of a number of Youtube plugins that make the site bearable again by forcing annotations off and 1080p on.

Re:Revisiting how we build Firefox by KwanEsq on Tuesday July 07, 2015 @01:34AM (#9843791)
You are misunderstanding the language being used.

Add-ons are brower extensions like the examples you provide.

Plug-ins are Flash, Silverlight, Unity Web Player, and the Java plug-in.

Only the going away of the latter is being called for.

Re:Revisiting how we build Firefox by masklinn on Tuesday July 07, 2015 @03:43AM (#9844085)
> Rikaisama

This is most likely an addon, a Firefox extension written in (mostly) JS and XUL. Plugins are the external runtimes embedded in browsers with NSAPI &al: Flash, Java, Silverlight, etc...

Re:Revisiting how we build Firefox by Larrikin on Tuesday July 07, 2015 @01:04AM (#9843730)
Can't reply, but the annotations off plugin is called "YouTube - Disable Annotations" by notsie
Re:Revisiting how we build Firefox by brobinson on Tuesday July 07, 2015 @01:31AM (#9843788)
Awesome, thanks!

Edit: eek, looks like it's been removed by the author :( https://addons.mozilla.org/EN-US/firefox/addon/youtube-disab...

Re:Revisiting how we build Firefox by brobinson on Tuesday July 07, 2015 @12:57AM (#9843708)
>forcing annotations off

Please share this miracle you speak of.

Re:Revisiting how we build Firefox by nightpool on Monday July 06, 2015 @03:48PM (#9841737)
a lot of modern firefox plugins are already written this way, but there are probably a significant amount of legacy addons that would need to be rewritten
Re:Revisiting how we build Firefox by at-fates-hands on Monday July 06, 2015 @04:37PM (#9842028)
This sounds a lot like what Adobe did with Brackets by building it with HTML, CSS and JS.

The advantages are numerous, so I can understand why they're going this route.

Re:Revisiting how we build Firefox by ocdtrekkie on Monday July 06, 2015 @05:00PM (#9842150)
Hat tip and an upvote for making this super easy to understand.
Re:Revisiting how we build Firefox by millstone on Monday July 06, 2015 @05:05PM (#9842181)
I hate the trend of building native UIs in HTML, because the result never feels right. For example, Firefox does not use OS X native context menus, and it shows in how they look, position themselves, animate, respond to keyboard and mouse events, etc.

But Firefox devs have clearly spent a great deal of effort to make these faux-context menus look native. What an enormous waste of development energy to emulate what the platform already provides!

Rather than pushing forward with a layer that provides even less access to platform UI elements, I wish they would recommit themselves to keeping the native elements native.

Re:Revisiting how we build Firefox by ianbicking on Monday July 06, 2015 @07:01PM (#9842699)
There's broadly two directions Firefox could go: do everything in HTML, or use native widgets. Firefox for Android initially used XUL just like Firefox desktop, but switched to native. They've had a lot of success with that. This email is the start of a discussion that will include that option.
Re:Revisiting how we build Firefox by DaveWalk on Monday July 06, 2015 @06:44PM (#9842629)
Is there an official line that Firefox is taking on this? As a novice to their development decisions, I've always wondered this myself.

I sometimes feel like I can sense when a UI is not native; it's completely useable, and I have no functional complaint, but it might just seem...off.

I felt a small bit of delight when I switched back to Firefox on my Windows machine and saw the snappy animations for new tabs and its menus. It made a kind of subconscious difference.

Re:Revisiting how we build Firefox by mnarayan01 on Monday July 06, 2015 @09:12PM (#9843113)
I would guess that there's some functionality provided via XUL which doesn't exist in the native OSX context menus (i.e. precisely the same functionality doesn't exist, not that the native OSX context menus are somehow deficient). That's going to be particularly relevant for extensions.
Re:Revisiting how we build Firefox by frozenport on Monday July 06, 2015 @07:56PM (#9842860)
A lot of people agreed with you and built Camino and K-Meleon.
Re:Revisiting how we build Firefox by drethemadrapper on Monday July 06, 2015 @09:28PM (#9843156)
I can't agree more. Where does this plan leave desktop app dev. with Mozilla technologies? There are tonnes of projects (desktop apps) using XUL, XPCOM, e.t.c. SUre, the future is the Web (like Web OS, Unity, i.e. UI in HTML). Why can't they improve on XUL/XBL by releasing a new version with the desired features while they try to simplify building extensions/apps with XPCOMs? They should standardize apps dev. for FFOS (gonk{+necko}/gecko/gaia) & FF(gecko+necko/xul). This effort does not necessarily mean spending much time on enhancing the UI for FF but rather ensuring seamless app. portability between FF and FFOS.
Re:Revisiting how we build Firefox by frozenport on Monday July 06, 2015 @09:34PM (#9843174)
Here is a difference of opinion:

If you want to share the same code base you need to grantee the same functionality. The easiest and most predictable way is to run this through an intermediate and then render that intermediate. This is why compilers use intermediate representations like bytecode, you don't want to write a compiler that builds only x86 and then another when you need to build ARM. You don't want to write a rendering engine with different implementations for each widget kit.

Re:Revisiting how we build Firefox by asmicom on Tuesday July 07, 2015 @10:10PM (#9849383)
Well, the XPCOMs represent the bytecode in your opinion. One still can't get an XPCOM for FF to work on FFoS, I meant the simplest one without making huge changes to the code base. Yes, one UI engine is needed and so is a (cross-)compiler in your case OR alteration of the code base for FFoS of FF to ensure portability. I guess it would be the FFoS code base that might need to change. BUt that could be tricky since it leverages the Andriod's core - a component-based linux OS.
Re:Revisiting how we build Firefox by asmicom on Tuesday July 07, 2015 @10:03PM (#9849358)
You are on point Dre! I know frustrating it could be building FF extensions and FFoS Apps. There need to be an efficient way to port one to the other.
Re:Revisiting how we build Firefox by glorien on Monday July 06, 2015 @02:47PM (#9841303)
The correct thing to use is AppKit on OS X, WPF on Windows, GTK+ on Gnome, and Qt on KDE. Yes, this requires more code, but it results in a much, much better experience. As an OS X user, it's so obvious when an app isn't properly using AppKit.
Re:Revisiting how we build Firefox by kaolinite on Monday July 06, 2015 @03:26PM (#9841573)
Could not agree more.

Firefox has traditionally not been very popular on Mac for this very reason. They've gotten better at imitating OS X slightly, but even today it's still out of the question for me (and I suspect many Mac users) to use Firefox. It feels really awful to use. Whilst Chrome and Safari have nice native scrolling, rubber banding and smooth zooming, just like any other native app, Firefox feels jarring. It only just supports gestures (there's no nice animation like in Safari or Chrome).

My day-to-day browser is Safari. Not because it's faster or technically better (it really isn't) but because it's fully native and integrates properly with the system, e.g. it integrates properly with the downloads folder (showing the progress bar on the file and on the folder icon) and it looks and feels like any other Mac app. Chrome may be faster, Firefox may be more extensible - but I choose Safari because it works properly with the OS.

I really love Mozilla and I would love to use Firefox. I really hope they go with a OS-specific native shell - although I suspect they'll go with building the UI in HTML/CSS. But if they do, there's a good chance I'll switch.

Re:Revisiting how we build Firefox by ndesaulniers on Monday July 06, 2015 @07:32PM (#9842803)
It's hard for me to believe someone telling me "if it's not 100% native look and feel it's not good" when they're trying to sell something and build a content silo.

> The correct thing to use is AppKit on OS X, WPF on Windows, GTK+ on Gnome, and Qt on KDE.

WHAT?! Personally, being asked to rewrite the UI for X different native platforms is rage-inducing.

Some people who write their apps in Web technologies have done native UIs and are sick of the duplicated effort. ;)

Re:Revisiting how we build Firefox by kccqzy on Monday July 06, 2015 @10:41PM (#9843347)
Well it's already been done before. Yes it's a lot of effort but the added user experience can be very valuable. Case in point: Transmission is a BitTorrent client that has at least a Web UI, an OS X native UI, a GTK+ and a Qt one. Using the app just feels right, and the little bits of joy while using just adds up.
Re:Revisiting how we build Firefox by jfb on Monday July 06, 2015 @08:12PM (#9842909)
Web UIs are great for developers, much, much less so for people who don't have an ideological axe to grind or a limited development budget.
Re:Revisiting how we build Firefox by marssaxman on Monday July 06, 2015 @09:23PM (#9843144)
They are entitled to be lazy, but you get what you pay for and web UKs are never as good as native.
Re:Revisiting how we build Firefox by ndesaulniers on Monday July 06, 2015 @10:35PM (#9843332)
> They are entitled to be lazy

I really, really don't think that is the case.

Re:Revisiting how we build Firefox by marssaxman on Tuesday July 07, 2015 @12:49PM (#9846569)
It's just a judgemental way of saying that they have not made UI quality a priority. They're saving money on dev time by asking users to put up with a lower-quality experience, and I always feel resentful and put-upon when I encounter such an app. I'm likely to scrap it out of spite and use something else which has a better interface, even if it is less featureful.

(also, what happened to the edit link? "UKs" was obviously supposed to be "UIs" above.)

Re:Revisiting how we build Firefox by ndesaulniers on Tuesday July 07, 2015 @06:37PM (#9848581)
> They're saving money on dev time by asking users to put up with a lower-quality experience

I think that the idea that somehow if the UI is written in web technologies that it's somehow lesser quality is a false dichotomy. Web developers and native developers can make UIs that look exactly the same to the point where they are indistinguishable.

You have 2 hours after posting to edit a ~~commit~~ comment. Not my favorite "feature."

Re:Revisiting how we build Firefox by marssaxman on Tuesday July 07, 2015 @09:18PM (#9849204)
Well, maybe they can, but I haven't seen it happen, and it has never been truly indistinguishable in the past when people have made similar claims. Cross-platform UI tools have been coming and going for years, and "write once, run anywhere" has always been a goal and not an accomplishment. People said the same thing about Java apps, but you could always tell - there was always something that didn't fit right, and the "uncanny valley" effect makes it hard to respond with anything other than revulsion when you realize that you're working with an elaborate fake.
Re:Revisiting how we build Firefox by phkahler on Monday July 06, 2015 @03:14PM (#9841483)
I'm used to agree. That's how you get a native look and feel, but I don't think that's necessarily what people want. I find the use of tabs in the browser to be very telling - it means the way OSes have handled multiple instances of an application are not satisfactory, so people want the browser to handle that. Once it's in the browser people will want it to be the same on all platforms.
Re:Revisiting how we build Firefox by blt on Monday July 06, 2015 @06:57PM (#9842681)
Someone should survey software end users to figure out if they care about native-looking UIs. I have a feeling most users don't care very much.

My most-used GUI apps are Chrome, Visual Studio, Ableton Live, and Photoshop. All of them have heavily customized user interfaces. Their custom controls and tiling/layout systems are tailored to the application domain. Except for Chrome, these are "do your life's work" applications. They should aim for maximum productivity, even if it makes the application harder to use. I think they would suffer if they tried to "look native".

Most everything else is done in web apps these days. Users don't seem to have a problem dealing with different button CSS in different web apps.

Certain things, like the "open file" dialog, really suffer if they look non-native. But I think users don't care about most other cases.

Re:Revisiting how we build Firefox by pcwalton on Monday July 06, 2015 @08:51PM (#9843032)
In a sense, Chrome has been moving further and further away from being native over time; in-content preferences, for example.
Re:Revisiting how we build Firefox by kaolinite on Monday July 06, 2015 @03:28PM (#9841587)
There's nothing wrong with designing custom UI elements, so long as they're done properly on each platform. For example, Safari's tabs are completely custom (as far as I know) - they can't be used in other applications, they aren't part of Cocoa - but they're tastefully designed and they work well.
Re:Revisiting how we build Firefox by jarek on Monday July 06, 2015 @03:30PM (#9841601)
As a non-OS X user, I would very much prefer Firefox developer time to be concentrated on things other than platform-specific UI code.
Re:Revisiting how we build Firefox by seanalltogether on Monday July 06, 2015 @04:27PM (#9841957)
Well they're either going to have people writing platform specific code, or people writing code to emulate and keep current with platform specific features.
Re:Revisiting how we build Firefox by cookiecaper on Monday July 06, 2015 @05:20PM (#9842253)
Agreed. I strongly dislike the philosophy espoused by the parent. "I recognize that other products are technically superior and allow me to do more things without inflicting undue hardship or learning curve, but because the animations aren't as nice, I'm just going to use this other thing." I have no interest in humoring those with such a vain and frankly indefensible perspective.
Re:Revisiting how we build Firefox by worklogin on Monday July 06, 2015 @05:55PM (#9842433)
What a comment! You made a binary discussion from a nuanced one. The question is whether an attractive UI (which, surprise, matters to many people) is worth focusing developer effort. Several comments in this thread advocate that non-native UIs look tacky, and that it would do well for the product to have native rendering.

As an aside, it's the no. 1 reason I don't use Atom: An ugly, slow UI that doesn't render native elements.

So no, it's not indefensible. I think your conspirator's OP comment "As a non-OSX user, I don't care about your UX" is more vain.

Re:Revisiting how we build Firefox by jarek on Tuesday July 07, 2015 @04:18AM (#9844178)
> I think your conspirator's OP comment "As a non-OSX user, I don't care about your UX" is more vain.

Sure it's vain. We all have personal priorities. People suggesting that Mozilla spend time developing the perfect OS X product are expressing their priorities as well.

I could say that I'm a BeOS user and I really think that Firefox should have a fully-integrated native UX because the way a product looks and works is important. But no one cares about BeOS UX because they're vain.

It looks like OS X users are the only ones who really care. Windows users have been dealing with non-standard UIs since tabs first stopped being MDI, and, comparing Chrome's adoption with how it looks, they're mostly fine with them. Linux users are mostly just straight-up crazy and Firefox is fine for them. Smartphone users have seen more non-standard than standard UIs and it doesn't seem to have been a problem for the Facebook app. The question is then is it worth caring as much about OS X UI, or is it more useful to make a better product for the 80+% of users who don't use OS X?

Re:Revisiting how we build Firefox by jfb on Monday July 06, 2015 @08:17PM (#9842922)
In what way is this a choice between "technically superior" and "nice animations"? The reasons that Firefox, for example, is terrible on OS X is not to do with the quality of the animations (although they are awful) but rather the semantics of user interaction, which are by definition different in non-native applications.

And, I'd argue, Firefox is far, far, far from "technically superior" on any number of axes, regardless.

Re:Revisiting how we build Firefox by matthewmacleod on Monday July 06, 2015 @05:57PM (#9842443)
It's really not indefensible, and you're sort of minimising a valid viewpoint that I wish more developers took on board.

User experience is important. Dismissing that aspect as "animations [that] aren't as nice" misses an important point - things like animation, consistency with the host system, integration with platform features and so on are really very important to the quality of an app.

Technical capability is also important, obviously. It's why I use Firefox and when building web projects on the Mac - best feature set. But I use Safari instead for day-to-day browsing, because of things like better scrolling and zooming, and better integration with platform services.

I do think the way a product looks and works is important, and developers who dismiss that are why we have so many awful UIs out in public.

Re:Revisiting how we build Firefox by cookiecaper on Monday July 06, 2015 @06:07PM (#9842483)
>User experience is important.

I agree user experience is important, but experience is so much more than simple aesthetics.

I'm not saying they're totally unimportant, which is why I included the qualifying clause about "undue hardship", but I have no respect for users that will put themselves at a functional disadvantage so that their experience can be "prettier" (aka "more native"). These people have their subculture, called "Apple", and frankly, I want as little to do with it as possible. Prioritizing glitz above function shows serious problems in critical thinking.

If we can make an application look better, cool, we should add that to the list somewhere. I'm not opposed to that. I strongly disagree that this should be anywhere near the primary criterion used to judge an application's value.

Re:Revisiting how we build Firefox by girvo on Monday July 06, 2015 @08:47PM (#9843015)
While discussing downvotes is considered bad etiquette, can someone explain why cookiecaper has been downvoted? They've expressed their viewpoint, respectfully and at some length. Downvotes because you disagree with their viewpoint is bad form.

Edited to add: And I disagree with them, however I'm downvoting to show disagreement is something that HN has always been against, to it's credit.

Re:Revisiting how we build Firefox by kccqzy on Monday July 06, 2015 @10:48PM (#9843382)
Because he accuses those who have different prioritization in the functional/experience tradeoff of having "serious problems in critical thinking"? It's a matter of opinion and not mental capability.
Re:Revisiting how we build Firefox by cookiecaper on Tuesday July 07, 2015 @01:21PM (#9846761)
I disagree. The person that will impede his ability to accomplish actual work because of his subjective aesthetic preferences is substantially less "mentally capable" than a person that will tolerate a bit of ugliness for greater efficiency. Again, it's a matter of degree because there are some programs that are so "ugly" that they are unusable, but the grandparent's specific example was Safari v. Firefox, and while Firefox may not conform to Apple's aesthetic standard exactly, it's far from unusable. The GP admitted that both Firefox and Chrome were superior to Safari in tangible ways that affect productivity, but that they continue to use Safari because they think it's prettier. I cannot comprehend that POV and have no respect for people who hold it, and that expands outside of software too.
Re:Revisiting how we build Firefox by matthewmacleod on Wednesday July 08, 2015 @11:40AM (#9852286)
I can see you've decided to ignore what I actually said and instead substitute your own version.

I'll tell you what I can't comprehend – people who apparently find it difficult to accept that other people have differing priorities to them, and aren't mentally subnormal as a result.

Re:Revisiting how we build Firefox by paublyrne on Monday July 06, 2015 @05:47PM (#9842394)
Look and feel are important to me in a product, amongst other things. I don't see that as something that needs defending.
Re:Revisiting how we build Firefox by basch on Monday July 06, 2015 @02:57PM (#9841384)
Camino was discontinued 3 years ago. https://en.wikipedia.org/wiki/Camino_(web_browser)

k-melon for windows http://kmeleonbrowser.org/

Re:Revisiting how we build Firefox by inDigiNeous on Tuesday July 07, 2015 @06:16AM (#9844525)
This would result in bugs between different UIs on different platforms, resulting in duplicated effort and codebase, and many frustrated developers who want to work on feature Y on platform X, and cannot port it to platform Z because of missing support or different implementations.

I don't really care if an application is native or not, Firefox works great for me on Os X and I really appreciate I can run the same browser on all platforms I have to use or developer for.

Re:Revisiting how we build Firefox by malkia on Monday July 06, 2015 @04:38PM (#9842034)
So if you don't use Gnome or KDE - what should be used? I'm using XFCE at home, and Cinnamon at work.
Re:Revisiting how we build Firefox by mappu on Monday July 06, 2015 @05:10PM (#9842209)
XFCE and Cinnamon are both primarily GTK+-oriented.

Although your point isn't lost. In 2015 Mozilla probably won't release a Motif build for the WindowMaker users.

Re:Revisiting how we build Firefox by rockdoe on Monday July 06, 2015 @02:54PM (#9841355)
You're just describing what sits underneath the XUL or HTML.
Re:Revisiting how we build Firefox by IshKebab on Monday July 06, 2015 @03:24PM (#9841548)
No he isn't?
Re:Revisiting how we build Firefox by reubenmorais on Monday July 06, 2015 @03:41PM (#9841680)
Well, most of it isn't, but some things are. Radio buttons and checkboxes on Gtk for example: https://mxr.mozilla.org/mozilla-central/source/widget/gtk/gt...
Re:Revisiting how we build Firefox by JoshTriplett on Monday July 06, 2015 @01:54PM (#9840905)
Mozilla has been doing experiments in building browser UI in HTML for a long time. For instance, see Chromeless ( https://blog.mozilla.org/labs/2010/10/chromeless-build-your-... ).

Current HTML is capable enough. It's nice to see them talking about adopting that in mainline Firefox.

Re:Revisiting how we build Firefox by agumonkey on Monday July 06, 2015 @02:36PM (#9841214)
Accidental downvote. I thought it was https://github.com/mozilla/browser.html , I never heard of this chromeless effort.
Re:Revisiting how we build Firefox by smacktoward on Monday July 06, 2015 @02:25PM (#9841101)
It's probably time (past time, actually) for Mozilla to start looking into putting XUL/XBL to pasture for Firefox UI and using HTML/CSS/JS instead, since the Web platform has become sufficiently capable that the arguments for having a separate stack of technologies for building UI don't really hold anymore.

Still makes me a bit sad to see it go, though; I'm old enough to remember when XUL seemed like an exciting potential platform for general-purpose app development. Which never really panned out, alas, but was fascinating at the time.

Re:Revisiting how we build Firefox by asadotzler on Monday July 06, 2015 @03:49PM (#9841743)
IMO, it did pan out. XUL and XBL provided the inspiration for much of what's come to real Web standards over the last decade or so. Thanks to XUL, we had a web-like model for front end dev that over time was usurped by a real Web model for front end dev. If we can re-implement Firefox using real Web standards, XUL will have been be a big part of the reason that became possible.
Re:Revisiting how we build Firefox by smacktoward on Monday July 06, 2015 @04:00PM (#9841814)
That's great for FF and Mozilla, but it doesn't feel like a win for those of us who were interested in XUL/XBL as a platform for building our own apps, independent of those Mozilla ships. I put a little bit of time into trying to build stuff on top of XUL before giving up on it, and that time ended up being more or less wasted -- it's not like there was an easy glidepath to take stuff built in XUL and move it to Web standards, because back then Web standards weren't up to the task. Combine that with the platform itself being a bit of a moving target as MozSuite/FF evolved and the end result was work I basically had to throw out.

I'm not mad at Mozilla for all that, lots of platforms are complicated to build on, especially ones that are new and still evolving (which XUL definitely was, at the time). It's just not an experience that I feel like I can put into the "win" category. It was a dead end, at least for my needs.

Re:Revisiting how we build Firefox by asadotzler on Monday July 06, 2015 @05:11PM (#9842215)
Yeah. I hear ya. As a platform for app development outside of Mozilla projects and products, it has definitely been a bumpy and often roadblocked path.
Re:Revisiting how we build Firefox by gsnedders on Monday July 06, 2015 @04:00PM (#9841807)
And Web Components owe a clear legacy to XBL2 (an abandoned W3C draft, the immediate forerunner to Web Components), which obviously had clear links to XBL (though was backwards incompatible).
Re:Revisiting how we build Firefox by simcop2387 on Monday July 06, 2015 @02:34PM (#9841196)
Yep, I remember actually building a toy 2d tilemapped RPG engine with it maybe a decade ago. It definitely wasn't capable of anything fancy then so I didn't do much more than have it let you move around the map with a simple UI around it . Now HTML/CSS/JS can completely blow it out the water with what you can do.
Re:Revisiting how we build Firefox by clarkbw on Monday July 06, 2015 @02:19PM (#9841063)
This email represents an intention to start investigating moving away from XUL/XBL. There are a number of areas to explore here like how to properly handle L10N, add-on overlays, and where to go native vs markup. At the same time we're actively moving over to e10s (electrolysis / per process tabs). There will be followup communication about who is doing the work and what work is being done but now is the time to add your concerns and comments or offer support.
Re:Revisiting how we build Firefox by abhv on Monday July 06, 2015 @03:31PM (#9841609)
Can XUL/XBL just be ``compiled-down" to proper HTML, or is there also a security issue in that Gecko allows XUL/XBL to break rules needed to securely render HTML?
Re:Revisiting how we build Firefox by ZenoArrow on Monday July 06, 2015 @04:25PM (#9841951)
That's a good question. I don't know the answer, but I'm curious as well. If it is an option, might be a good interim solution, perhaps not for the main UI (where performance is one of the main goals) but it could be useful to help the plugin ecosystem transition over.
Re:Revisiting how we build Firefox by shmerl on Monday July 06, 2015 @03:08PM (#9841453)
> Is there space for a native-code main-window on desktop like we have on Android?

Sailfish browser did it as well (using native UI). Desktop Firefox also can benefit from IPCembedlite. But the question will be, what should be used to write the UI. Qt as well?

I'm a bit torn on that, since switching away from "Webby" interface basically killed Fennec for Meego, and only Android started getting UI improvements (that's what triggered a separate browser for Sailfish to begin with).

Re:Revisiting how we build Firefox by gcp on Monday July 06, 2015 @04:28PM (#9841969)
Meego dying killed Fennec. It would have gotten further development if it had had users that warranted so.
Re:Revisiting how we build Firefox by shmerl on Monday July 06, 2015 @04:52PM (#9842102)
Meego became Mer on which Sailfish is based, and it has enough users, so your argument is invalid.
Re:Revisiting how we build Firefox by ShalokShalom on Thursday July 09, 2015 @07:25PM (#9861379)
Please please please :D

Use this chance and port Firefox to Qt:

There are a lot pro`s, who speak for that, front in the row the huge community, the portability, the performance, and the fact that many devs rewrite there existing GUI to Qt, like Musesore, Frescobaldi, Wireshark, Subsurface, VLC, Gcompris, Mkvtoolnix, Dropbox, Megaglest`s Map editor, OpenShot, ufw-frontends, Dolphin-Emu and even two DEs: LXDE and Unity.

Please do that and i am Firefox user for my lifetime. :)

Re:Revisiting how we build Firefox by drapper on Monday July 06, 2015 @04:00PM (#9841815)
That reminds me of what Vivaldi is trying to do (https://vivaldi.com/)
Re:Revisiting how we build Firefox by hitlin37 on Tuesday July 07, 2015 @04:32AM (#9844226)
Good thing is servo team is supporting API compatibilty with chromium CEF project. That mean, if you write an html5 app using CEF, it will just work so with servo engine as well.
Re:Revisiting how we build Firefox by chovy on Tuesday July 07, 2015 @12:41AM (#9843671)
It would be cool if they took something like NWjs or Electron and made it better. So we could build other apps besides a browser with a cross platform framework.
Re:Revisiting how we build Firefox by therealmarv on Monday July 06, 2015 @04:32PM (#9841999)
Keep XUL, XBL. Mark it deprecated. Make plugin development as easy as in Chrome for the new API. Would be awesome and so appreciated!
Re:Revisiting how we build Firefox by madez on Monday July 06, 2015 @04:22PM (#9841938)
Does this imply that It wouldn't possible anymore to use Firefox to browse without Javascript?
Re:Revisiting how we build Firefox by gcp on Monday July 06, 2015 @04:28PM (#9841961)
Firefox already uses a ton of JavaScript internally. The setting for web content has nothing to do with the internals of the browser.
Re:Revisiting how we build Firefox by rockdoe on Monday July 06, 2015 @02:55PM (#9841366)
The faster deployment thing seems pretty vague and free of actual content.
Re:Revisiting how we build Firefox by azakai on Monday July 06, 2015 @03:24PM (#9841549)
A few more bits of info from Laura Thompson's presentation, that was mentioned: shipping features can be done even faster if they are done in a modular way, as addons. Firefox supports restartless addons, which means the browser could download an addon and enable it immediately.

Together with work on improving addon APIs (APIs for CSS features were discussed, for example) this could be very interesting.

Re:Revisiting how we build Firefox by kazagistar on Tuesday July 07, 2015 @02:29AM (#9843905)
If this means that I could easily uninstall all the bits of firefox I don't use, like bookmarks, that would be pretty cool.
Re:Revisiting how we build Firefox by ZenoArrow on Monday July 06, 2015 @04:16PM (#9841904)
Here's how I read it... they're looking at ways to move towards rolling release for A/B testing.

Think about it like this, you're using Firefox and you get a notification... "Feature X is ready to test, would you like to try it out? Yes/No" If you select Yes, the feature is rolled out to you and other volunteers immediately (potentially without restarting, depending on the feature), and you can then feedback your experience to Mozilla on how well the new feature works out for you. The feedback from this control group then informs whether Feature X is ready for prime time.

In some ways it seems like it's a restructuring of the Firefox development channels, a mix of beta and stable releases in the same channel.

Re:Revisiting how we build Firefox by lxt on Tuesday July 07, 2015 @03:25PM (#9847534)
This is kind of what we have in mind.

The model is that we want to make Firefox itself more webby in the way it ships. Features should be independently updatable from the core browser, and we should be able to do phased rollouts to help us watch for issues, control for load, and so on.

We are looking at offering very experimental stuff in a purely opt-in process, and updates to regular features as if they were third party add-ons (with some twists in how they have to be implemented).

Re:Revisiting how we build Firefox by lxt on Tuesday July 07, 2015 @03:21PM (#9847513)
It's mentioned only briefly here since the email is mostly about XUL/XBL.

I'm working on the Go Faster project. We hope to deliver a 1-2 features this way by the end of 2015. We have just started on building out needed changes to the client, update service, and build pipeline.

Re:Revisiting how we build Firefox by gesman on Monday July 06, 2015 @05:42PM (#9842371)
Please keep these little icons unchanged, i don't care about it.

Do not make tabs cuter, I don't care about it.

But PLEASE - do something to stop Firefox from being such a bloated memory hog - I deeply care about it.

Re:Revisiting how we build Firefox by chuckharmston on Monday July 06, 2015 @08:17PM (#9842924)
Firefox itself is quite fast [1]; if you're having issues, there's a good chance that it's due to an add-on [2]. A (historically; I'm unsure if this is still the case) particularly egregious offender [3] is AdBlock Plus, but µBlock [4] does come highly recommended.

[1] http://arewefastyet.com

[2] https://support.mozilla.org/en-US/kb/firefox-uses-too-much-m...

[3] https://blog.mozilla.org/nnethercote/2014/05/14/adblock-plus...

[4] https://addons.mozilla.org/en-us/firefox/addon/ublock/

Re:Revisiting how we build Firefox by gesman on Monday July 06, 2015 @08:20PM (#9842934)
I didn't say it slow. It is indeed fast. Thank you for that!

Until suddenly the show stops and I have to kill it via Taskmgr to inject new life into it due to memory suffocation.

Re:Revisiting how we build Firefox by chuckharmston on Monday July 06, 2015 @08:25PM (#9842942)
Hmm...that doesn't sound like normal behavior; my uneducated guess would be that there's a specific webpage or extension with a leak. Next time it happens, it'd be fantastic if you could go to about:memory, save the reports, and file a bug with them attached:

https://bugzilla.mozilla.org/enter_bug.cgi?product=Firefox

Re:Revisiting how we build Firefox by sp332 on Monday July 06, 2015 @08:19PM (#9842928)
Firefox is not a bloated memory hog (anymore).
Re:Revisiting how we build Firefox by gesman on Monday July 06, 2015 @08:22PM (#9842938)
I'll send you a memory consumption snapshot soon. 8 tabs == 1GB memory already but i can live with it for now. When it eats 3GB+ -- and unfortunately it will - then it'll become an issue.
Re:Revisiting how we build Firefox by sp332 on Monday July 06, 2015 @09:42PM (#9843198)
Do you have unusual plugins that might be using a lot of RAM? Do the same tabs take up less memory in Chrome?
Re:Revisiting how we build Firefox by voltagex_ on Monday July 06, 2015 @09:43PM (#9843200)
about:memory
Re:Revisiting how we build Firefox by ris on Monday July 06, 2015 @03:37PM (#9841645)
I'd rather they'd spend more time making their rendering engine e.g. implement the SVG spec properly[0] than fanny about with this, but, y'know, I'm not in change.

[0] https://bugzilla.mozilla.org/show_bug.cgi?id=437554

Re:Revisiting how we build Firefox by maccard on Monday July 06, 2015 @05:58PM (#9842453)
Feel free to contribute, FF is an open source project driven by people like you who get annoyed at bugs like this.
Re:Revisiting how we build Firefox by ris on Monday July 06, 2015 @06:07PM (#9842487)
Many a time I've said this to people but truth is the number of projects I already contribute to is greater than the time I really have to devote to them.