XUL was pile of garbage riddled with bugs. I've made Todo app in remote XUL and every 30 minutes of development I encountered some major functional bug. Idea was great but implementation was terrible. I've used many UI frameworks over the years but when I see three letters XUL, the first flashback I have are all those bugs.

That's surprising. I wrote an extension back in the days, I think it was Firefox 1.5, I used XPCOM to use C code and it worked well. I don't remember stumbling into too many bugs. Actually I liked XUL and I thought that it has great future, because it was so much better for UI than HTML.

Even though there are still bits of XUL in Firefox, the XUL tech itself has not been maintained along with the rest of Gecko. It was probably not in much of a better state in Firefox 56 than it was back when you were working with it.

Would you care elaborating why it is better than HTML5?

"HTML5" + things like css grid and flexbox that you need to build UI in a sensible manner are pretty new inventions. XUL predates them dramatically, building UI in HTML at the time would have been an absolute nightmare. I know because I had to ship it in multiple applications

I understand that it probably was a better technology at the time. But are there any concepts/technologies in XUL that would be useful to add in the HTML standard?

It's a minor problem, but CSS, unlike XUL, doesn't provide a way to crop text in the middle[1][2].

[1] - https://www.w3.org/wiki/Text-overflow_middle_cropping

[2] - https://developer.mozilla.org/en-US/docs/Archive/Mozilla/XUL...

Cropping text in the middle is extremely hard to spec and implement for general inline CSS. Cropping at the start or end can be implemented as a purely paint-time operation. Cropping in the middle means you have to change the layout, and you have to define the layout of the stuff in the middle that has been cropped away in case someone does element.getClientRects() etc. It is far from obvious how that should work.

XUL texboxes avoided this problem by only supporting a single plain text string, but applying that constraint to HTML+CSS would be incredibly ugly (and people soon be complaining about that constraint, anyway).

HTML5 (2014) and Firefox 1.5 (2005) were not contemporaneous.

I think that XUL had better layout engines, suitable for apps instead of web pages. May be with modern CSS this gap is closed. Also native controls were nice.

We had a special version of firebug used to debug firebug itself and also XUL. It was never stable enough to deploy for general use, so I get it. But it did help quite a bit to see what was happening.

Remote XUL? Never even heard of that. My experience writing regular local client xul with HTTP calls went pretty snoothly

XUL was like the early internet: full of amazing possibilities, open, and security-oblivious.

Web extensions are severely limited, mostly because of security considerations, that is, to protect against malicious code.

Web is no more a friendly children's sandbox it was in 1995.

Web extensions are not limited because of any inherent limitations in technology but because of policy.

If Firefox wanted they could have created a new extension system with XUL that would also have the same limitations the web extensions do. For fairly obvious reasons they decided to transition to Web tech based extensions and used that opportunity to tighten up security as well.

Whenever you have a chance to do something in a declarative way, it's the better way to go IMO. Sad to see XUL removed... newer Firefox extensions are integrated much more poorly and are slower when the browser is busy (due to JS). Probably not noticeable for one tab though.

> security considerations, that is, to protect against malicious code.

Only in the "cannot fuck up your computer" kind of way. All addons I've installed still require "Access your data for all websites", thus have full access to my online life. Thus I only install addons from sources/authors i trust, just like back when jQuery was the coolest thing.

What is the closest thing we have left that is close to “mostly declarative GUI”? QML? Tk? Please don't say Electron.

XAML, but it Microsoft-specific. While not completely uniform its use does extend across desktop and mobile. I wouldn't make the argument that it's intuitive or simple, but it is powerful.

WPF is open source[1], but there isn't any effort to port it as far as I know. WPF also had a few warts compared to Silverlight.

[1]: https://github.com/dotnet/wpf/

JavaFX and QML are pretty much based on XAML.

Xaml and Javafx where released within 6 months of each other I kinda expect parallel implementation rather than copying. Just form the dates in Wikipedia

JavaFX was initially J3, and then it was rebooted into XAML like.

Also you're forgetting Longhorn SDK was available as preview before the project was canned.

But yeah just conspiracy theories from my side.

MXML. The Markup system for Adobe Flex is almost certainly the inspiration for both.

React Native? SwiftUI?

Lazarus/Freepascal. Cross platform, real native x86_64/ARM/Atmel/Etc.

GTK sort-of fits the bill

I recently built something with PyQt bindings and it works really well:

https://gitlab.com/djsumdog/mpvbuddy

In my previous job I wrote a couple of not-too-complicated apps targeting Linux in PyGTK and I found it to be pretty pleasant, except when it came to custom styling.... mainly because the styling language does didn’t seem well documented and i found it to be somewhat arcane. Didn’t stop me though and the project got done. I wouldn’t mind working with it again

There's JavaFX with FXML.

XUL wasn't native.

It rendered GTK I believe? Which used native controls.

I used to build a Firefox addon and the things you could do were amazing -- I could render into the status bar and popup a native window fed with data from a remote server. All from an XML file and some javascript! And you could style it with CSS!

The hacks and contortions addons have to go through now just to do something like that are insane, and the results are almost always janky as fuck.

XUL is just themed to look like GTK it's no more native than HTML is.

If whatever’s rendering eventually maps to native API calls I’d consider it native, and I’m pretty sure GTK does native calls. If XUL really did mimic GTK (which I’m pretty sure it doesn’t, a lot of other GTk apps had the same feel as Firefox back when most of its UI was native dialogs) then it’s the best damn mimic job I’ve ever seen

XUL had bindings to supported native widgetsets.

The important part is how it appears to the user. XUL appears like a proper native program, not like a web page.

What was so amazing about it?

For it's day it really was the most "native feeling" or at least "least janky" cross platform framework.

It's called "evolution". You have a tiger. You kill it. Now you have no tiger but you can have a cat from your neighbour.