-
Notifications
You must be signed in to change notification settings - Fork 1
Browser Support Philosophy
Appify is intentionally selective about which browsers it supports.
The goal is not to support every browser that exists on Linux. The goal is to provide a reliable, consistent experience for browsers with meaningful usage among Appify's intended users, while staying true to Appify's core architecture.
"Technically launchable" does not automatically mean "supported."
Appify may be able to start a browser and open a URL without formally supporting it. A supported browser must meet Appify's broader feature, compatibility, and reliability requirements.
Appify does not bundle its own browser or WebView. It uses the browsers you already have installed, including native, Flatpak, and Snap installations.
This keeps resource usage low and lets users benefit from their existing browser's updates, security patches, extensions, and browser-specific features.
Appify configures and manages the browser rather than replacing it with another runtime.
Every installed web app gets its own dedicated browser profile.
Extensions must work correctly inside that profile. Features such as extension presets, custom extensions, and Firefox CSS rely on proper extension support and reliable profile handling.
Appify therefore treats extension support as a real application capability, not an optional checkbox that can be advertised even when the browser cannot actually provide it.
A browser is considered for support when two conditions are met:
- There is clear demand or a meaningful use case for running web apps with it.
- The browser fits Appify's model without requiring special-case behavior that compromises existing features or consistency.
Appify can technically support additional browsers with relatively little code in many cases. That does not mean every technically compatible browser should become an officially supported browser.
Supporting a browser that only "kind of works" creates confusion, inconsistent behavior, and additional support burden.
Appify prefers a smaller set of fully supported browsers over a long list of partially supported ones.
Every supported browser should meet the same quality bar, even when the underlying implementation differs between browser families.
Appify currently supports:
- Google Chrome
- Chromium
- Microsoft Edge
- Brave
- Brave Beta
- Brave Nightly
- Brave Origin and its release, beta, and nightly variants
These browsers share a common command-line and profile model that Appify can handle consistently, including isolated profiles, WebHID/gamepad configuration, extension support, and browser-specific launch options.
Brave variants are detected individually where necessary so that Appify can launch the correct installed browser rather than assuming that every Brave installation uses the same executable or package identity.
Appify currently supports:
- Firefox
- Firefox Beta
- Firefox Developer Edition
- Firefox Nightly
- Firefox ESR
Firefox receives first-class support alongside Chromium-based browsers, including:
- Isolated profiles
- Extension support
- Optional
userChrome.css - Optional
userContent.css - The Remove navigation bar feature
- Firefox-specific browser configuration
-
.jsfiles are not supported, they are manually added as this is niche.
Firefox and Chromium do not implement every feature in exactly the same way. Appify handles those differences internally so that users receive a consistent application experience.
For example, Chromium applications use the browser's --app mode for minimal browser chrome, while Firefox applications can use Appify's generated userChrome.css rules to provide a similar app-like interface.
Falkon is a lightweight, Qt-based browser and is technically capable of opening websites.
However, Appify treats browser extensions as a first-class feature. Users can install extension presets, add custom extensions, and expect those extensions to work inside each app's isolated browser profile.
Falkon does not provide the WebExtension support required for Appify's extension model.
Supporting Falkon would therefore create one of two problems:
- A false positive: Appify would present extension-related functionality that cannot actually work in Falkon.
- Special-case behavior: Appify would need to disable or hide extension-related features specifically for Falkon.
Neither approach fits Appify's architecture.
The issue is therefore not that Falkon cannot open a website. It is that Falkon cannot provide the complete application environment that Appify promises.
For that reason, Falkon is not officially supported.
Konqueror is a historically important browser and an important part of the KDE project.
However, relatively few users run it as their primary browser for modern web applications. It also does not align well with the capabilities Appify is designed around, including modern web compatibility, extension support, and consistent profile and launch-flag handling.
Adding Konqueror would increase maintenance and testing requirements without providing a meaningful benefit to the majority of Appify users.
For those reasons, it is not currently supported.
Other browsers may be omitted when they:
- Have very limited use for general web applications
- Lack modern extension support
- Do not provide the profile isolation Appify requires
- Cannot expose the launch configuration Appify depends on
- Require extensive browser-specific handling
- Would create inconsistent behavior or user-facing limitations
This does not mean these browsers can never be supported.
Appify can often add support for additional browsers with relatively little code. The decision is deliberate: every officially supported browser must meet the same quality bar.
When evaluating a request for a new browser, Appify considers the following questions:
- Do users have a meaningful reason to run web apps with this browser?
- Does the browser support proper isolated profiles?
- Does it support WebExtensions in a way that works with Appify's extension features?
- Can Appify reliably detect the browser in native, Flatpak, and Snap installations where applicable?
- Can it be launched with the class of flags and options required by Appify?
- Can Appify provide reliable desktop integration for it?
- Does the browser provide the web compatibility expected by modern web applications?
- Would supporting it require special-case logic that complicates the codebase or confuses users?
- Can the browser be maintained and tested without creating disproportionate support requirements?
A browser does not need to behave identically to Chromium or Firefox.
It does need to provide a coherent environment in which Appify's core features can work reliably.
When the answers are clearly positive, support can be added.
Appify distinguishes between a browser being technically compatible and being officially supported.
A technically compatible browser may be capable of:
- Launching from Appify
- Opening a website
- Creating or using a browser profile
- Accepting some Appify launch options
That alone is not enough to qualify as supported.
Official support means that Appify can reasonably promise that the browser works with the application's core model and that the features exposed by the interface behave as users would expect.
This distinction is important because Appify intentionally exposes features such as extensions, isolated profiles, kiosk mode, browser customization, WebHID/gamepad support, and browser-specific launch configuration.
A browser that cannot support those capabilities should not be presented as though it does.
Appify is designed around the idea that users should be able to choose the browser they already trust and use.
A user may prefer Firefox because of its extension ecosystem and privacy controls. Another may use Brave, Chromium, Edge, or Chrome because of compatibility with a particular service. Some users may maintain multiple browser variants for different purposes.
Appify does not require users to switch browsers just to create web apps.
Instead, Appify adapts its application management layer to the browser.
This is why browser support is broader than simply selecting an executable. The browser must fit into Appify's profile, extension, launcher, and desktop integration architecture.
Appify does not aim to support every browser that can technically open a website.
It aims to support browsers that have meaningful user demand and can provide a reliable application environment within Appify's architecture.
The guiding principle is:
Supporting fewer browsers fully is better than supporting many browsers partially.
Every supported browser should meet the same quality bar for isolation, extensions, browser configuration, and desktop integration, even when the implementation differs between browser families.
Additional browser support is always possible, but it is evaluated based on user need, architectural fit, feature compatibility, and long-term maintainability, not simply whether Appify can launch the browser.