Learn how Flux works under the hood, how we protect your privacy, and answers to advanced technical queries.
Privacy is our core philosophy. Flux collects zero personal data, tracking cookies, or browsing history. All operations occur 100% locally in your browser. Your preferences (like target currencies and disabled sites) are stored locally using chrome.storage.local and never leave your device. Flux is also completely open-source, so you can inspect the code yourself on GitHub.
Flux fetches live currency rates from a reliable, global CDN API. To keep your browsing experience lightning-fast and save network bandwidth, rates are cached locally in your browser's storage and updated periodically. This ensures that price conversions happen instantaneously without lag.
Yes, perfectly! Flux is optimized for modern web apps like Amazon, YouTube, and Twitter. It uses a high-performance, debounced MutationObserver together with requestAnimationFrame. It watches for changes in the DOM and converts newly loaded prices dynamically as you scroll or navigate, without affecting website performance.
Absolutely. You can toggle Flux globally or disable it for specific domains (like local banking or web apps where you want original pricing) with a single click on the power icon in the extension popup.
Flux is officially supported on Google Chrome, Mozilla Firefox, and Microsoft Edge. It also runs flawlessly on other Chromium-based browsers like Brave, Opera, Vivaldi, and Arc.
The ≈ badge is a subtle indicator that the price has been converted by Flux. This helps you quickly distinguish converted prices from native page prices. You can easily turn this badge on or off from the extension settings popup.
Yes. In the extension settings menu inside the popup window, you can toggle the 'Show Badge' preference. Toggling it off will instantly remove the ≈ sign next to all parsed rates without disabling the conversion itself.
Flux stores rates locally. The background worker refreshes these rates from the CDN API every 24 hours. However, a manual reload or changing the target or base currencies in the settings popup will trigger an immediate, fresh background API fetch to keep rates as up-to-date as possible.
No. Flux is designed to be completely trackers-free. We do not use Google Analytics, Sentry, or any other telemetry libraries. Crash diagnostics are kept in your browser's local dev tools console and are never sent to a remote server.
Yes, Flux is 100% free and open-source. There are no ads, no trackers, no subscription models, and no hidden premium features. It is built and maintained by the community under the MIT license.
For development or manual installation:
git clone https://github.com/Satya-Siba-Nayak/Flux-Extension.gitchrome://extensions, enable Developer Mode, and click Load unpacked. Select the project directory.about:debugging, click This Firefox, choose Load Temporary Add-on, and select the manifest.firefox.json file.Flux uses a MutationObserver to listen for dynamic DOM modifications. To avoid lagging the page, changes are collected in an array and debounced with a 100ms window. When the timer fires, the nodes are processed in bulk inside a requestAnimationFrame loop, avoiding CSS layout thrashing and maintaining a smooth scrolling experience.
Flux avoids observer recursion by registering all processed nodes in a WeakSet (processedNodes). When a price text node is converted and wrapped in a span tag, it is cached, and the observer immediately skips any nodes that are already in the set or are descendants of already-processed elements, stopping loop feedback instantly.
Flux resolves symbol conflicts using JavaScript negative lookbehinds. For example, standard USD is searched using the pattern (?<![CAS])\$ which prevents matching CAD (C$), AUD (A$), or SGD (S$) as US Dollars. This ensures precise, isolated parsing and correct target currency swaps.
In Manifest V3, background service workers shut down after brief periods of inactivity. Flux handles this gracefully by storing all persistent state variables (base currency, target currency, enabled domains) inside chrome.storage.local. Message passing calls from content scripts wake up the service worker whenever requests are triggered, bypassing ephemeral worker memory lifetimes.
Standard MutationObservers attached to document.body do not traverse Shadow DOM boundaries. To parse shadow root content, observers must be attached to individual shadow host roots. Currently, Flux focuses on light DOM tree scanning, but developers can manually traverse shadow tree roots by piercing them using the element.shadowRoot reference in selectors.
By default, standard extension content scripts only execute in the top-level window context. Flux configures "all_frames": true in its extension manifest to inject content scripts into all nested iframe environments. However, cross-origin iframes (like third-party payment gateways) are subject to browser security sandboxes. If an iframe resides on a different domain, Flux handles it as a completely independent execution context, fetching rates securely from chrome.storage.local inside that frame's sandbox.
To avoid corrupting user-inputted values, disrupting checkout forms, or breaking interactive widgets (like code editors), Flux's parser implements a strict blacklist of ignored tags. The scanner completely skips elements with tag names like INPUT, TEXTAREA, PRE, CODE, SCRIPT, STYLE, NOSCRIPT, and any element or parent container marked with the contenteditable="true" attribute.
To ensure browsing remains butter-smooth, Flux performs a fast pre-flight scan using native, non-regex substring checks (such as verifying the presence of digits) before running heavy pattern matches on text nodes. Additionally, all currency matching regular expressions are designed with linear execution characteristics, avoiding nested quantifiers that cause catastrophic backtracking (Regular Expression Denial of Service) even when scanning very long blocks of text.
Locale styles vary widely (e.g., European 1.234,56 € vs. US $1,234.56). Flux uses a context-aware parser that analyzes spacing, character positions, and trailing digit structures to deduce which characters act as grouping separators and which act as decimals. Once the numerical value is normalized, the target price is formatted clean back to the page using the user's localized settings via the browser's native Intl.NumberFormat API.
Chrome's chrome.storage.sync API has a strict total storage quota of 100KB and writes are throttled to a maximum of 1,800 operations per hour. Because currency rate JSON tables containing conversion indices for over 150 currencies are large, writing them to sync storage would quickly exceed limits and crash the extension. Flux stores these large rate tables in chrome.storage.local, which has unlimited storage space (up to the browser's quota limit), while using the synced store only for lightweight settings like preferred user currencies.
Rates are fetched and managed inside the extension's Service Worker (background.js) and stored in chrome.storage.local. Decoupling the network requests from page-load content scripts prevents slow page rendering. When content scripts match price elements, they read rates synchronously or via message passing from local storage variables, guaranteeing zero delay.
Flux utilizes Fawaz Ahmed's open-source currency-api. Rates are served via jsDelivr CDN and cached locally on the client. The fetch is performed securely via HTTPS without passing any client keys, tokens, or unique device identifiers, guaranteeing complete network anonymity.
We welcome all contributions! You can fork the repository, pick a task or fix a bug, and submit a Pull Request. Ensure that you run the lint checkers and compile tests locally before pushing to GitHub: npm run lint and npm run lint:fix. Check out our Contribute Guide for all rules.