Have you tried `firefox --no-remote --profile <path>`?

In my case, I am able to launch several Firefox instances with distinct profiles.

Note that `--no-remote` breaks starting new browser windows from outside, which users normally want.

I'm starting to think that setting the `HOME` environment variable is the only way to really make things isolated - this still won't handle `~insertusernamehere` but basically everything else respects it.

--no-remote doesn't do anything anymore. It was removed about a year ago if memory serves.

I do `open -n "/Applications/Firefox.app" --args -p myprofilename` and that does the trick on mac

On windows powershell I do Start-Process "C:\Program Files\Mozilla Firefox\firefox.exe" -ArgumentList "-P default-release" Which is the exact same idea.

How does that integrate with the "Dock" or menu bar at the bottom? (new to Mac)

Yes, I tried that and everything else. Either it refuses to launch with `--new-instance` or (from memory, in the case of your command) subsequent `--new-tab`s may open in the wrong profile. Presumably due to the order in which the original instances were created. The point is that the system turns on these UIDs, which are not paths or even hashes of paths.

I tried Helix two years ago, unfortunately the default keymap was a bit frustrating to me. I don't mind changing my habits, however I had difficulty I made sense of the keymap design.

For example, typing `w` select the word. However, typing `2w` select the second word and not two words. To select two words you have to enter in visual mode (`v2w`). To remove two words you thus need to type `v2wd` or `wdwd`. In Vim you can type `d2w`. I miss this composability. In Kakoune (one of the main inspiration of Helix), you can type `2Wd` (`2wd` has the same behavior as Helix).

I was also hoping that the use of Ctrl/Alt modifiers be completely removed. Why not fully embrace modal editing?

If I remember correctly, TCO is now part of the ECMAScript standard. Safari has implemented it. The issue is that others engines have not because they are concerned about stack unwinding and stacktraces.

UFCS and the implicit `result` variable remember me the Eiffel programming language [0].

[0] https://en.wikipedia.org/wiki/Eiffel_(programming_language)

The following articles may also be of interest to the audience:

- The definitive guide to error handling in Rust [0]

- Error Handling for Large Rust Projects - Best Practice in GreptimeDB [1]

- Designing error types in Rust [2]

- Modular Errors in Rust [3]

[0]: https://www.howtocodeit.com/articles/the-definitive-guide-to... [1]: https://greptime.com/blogs/2024-05-07-error-rust [2]: https://mmapped.blog/posts/12-rust-error-handling [3]: https://sabrinajewson.org/blog/errors

I was quite excited by the description and then I noted that Bolt heavily relies on double floating point numbers. I am quite disappointed because this doesn't allow me to use Bolt in my context: embedded systems where floating point numbers are rarely supported... So I realized that I misinterpreted `embedded`.

Same here! It's very cool but my ideal use case would be on a limited ISA architecture like ESP32.

Bolt doesn’t support ARM or RISC. There’s some comments above re: the confusion with the term “embedded” and “real time”.

I think you might have misread our comments, that is exactly what we are lamenting.

I like the idea of repeating the delimiter on every line. However `//` looks like a comment to me. I could simply choose double quote:

    const still_raw =
        "const raw =
        "    "Roses are red
        "    "  Violets are blue,
        "    "Sugar is sweet
        "    "  And so are you.
        "    "
        ";
        "
    ;

This cannot be confused with a string literal because a string literal cannot contain newline feeds.

What if you have something like

    const raw =
        "He said "Hello"
        "to me
    ;

Wouldn't that be a mess to parse? How would you know that "He said " is not a string literal and that you have to continue parsing it as a multiline string? How would you distinguish an unclosed string literal from a multiline string?

I got a 404. IS the website still online?

Yes, and I think it's unlikely that it will support other platforms in future because it's based on Safari.

It’s coming on Linux (scheduled for March 2026). See https://kagi.com/changelog#6479

They started working on a Linux version this year. There are already WebKit based browsers for Linux so definitely it does not have to be confined to macOS.

Konqueror is among one of those Linux browsers, it became WebKit. It does not make a port easy though.

It's based on WebKit.

> Rust didn’t fire us. But a Rust rewrite without team buy-in can change who the team even is.

Perhaps the most valuable paragraph of this sad story.