Desktop Apps

RevIQ works in any desktop app that renders its UI with web technology. If your app shows HTML in a window, you can monetize it with RevIQ.

Supported frameworks

Electron, with first-class support through the rev-utils helper (see below)
Tauri
NW.js, CEF, Wails, Neutralino and other Chromium- or webview-based frameworks
Native apps with an embedded webview: WebView2 (Windows), WKWebView (macOS) and WebKitGTK (Linux)

Add the RevIQ script to the page your app loads, the same way you would on a website. See Frontend. Then make sure your app meets the two desktop requirements below.

Desktop requirements

Open ad clicks in the user’s default browser. When someone clicks an ad, open the landing page in their default browser rather than navigating your app’s window. Only open links in response to a real click. Block navigations and popups the user didn’t trigger, and block file downloads started by ads.
Send a standard browser User Agent. Many frameworks add their own name, and your app’s name, to the User Agent string (for example Electron/… or MyApp/…). Remove those parts so the string looks like a regular browser. Non-standard User Agents may be flagged as IVT (invalid traffic).

Electron

rev-utils handles both requirements for you.

Installation

Install the rev-utils library to augment your Electron setup with full compatibility for ads. We may occasionally update the package.

npm i -D rev-utils@https://r2.reviq.app/rev-utils-v1.0.3.tgz

Usage

After creating a window with new BrowserWindow, pass the window and the electron global into setupRevUtils.

main.js

const { setupRevUtils } = require("rev-utils");

// Note the import of the global electron here!
const electron = require("electron"); 
// You can destructure your imports from this module object
const { BrowserWindow } = electron;

const myWindow = new BrowserWindow();

setupRevUtils(myWindow, electron);

Under the hood, setupRevUtils calls two functions on the window

setupLinkHandler to open ads (and block malicious behavior!)
setUserAgent, which removes non-standard portions of the User Agent string which may trigger IVT (invalid traffic).

Tauri

Build a page on your domain with the RevIQ script and your ad slots (see Frontend), then show it in a child webview that sends a standard User Agent and opens ad clicks in the user’s browser.

src-tauri/src/ads.rs

use tauri::webview::{NewWindowResponse, WebviewBuilder};
use tauri::{LogicalPosition, LogicalSize, WebviewUrl, Window};
use tauri_plugin_opener::OpenerExt;

// A standard Chrome User Agent. Ad providers don't recognize Tauri's default.
const ADS_USER_AGENT: &str = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36";

pub fn add_ads_webview(window: &Window) -> tauri::Result<()> {
    let url = "https://your-domain.com/app-ads.html".parse().unwrap();
    let builder = WebviewBuilder::new("ads", WebviewUrl::External(url))
        // Ads render in iframes, so the click script must run in every frame.
        .initialization_script_for_all_frames(include_str!("ads-init.js"))
        .user_agent(ADS_USER_AGENT)
        // Ad clicks go through open_ad_link, never through new windows.
        .on_new_window(|_, _| NewWindowResponse::Deny);

    window.add_child(
        builder,
        LogicalPosition::new(0.0, 0.0),
        LogicalSize::new(300.0, 250.0),
    )?;
    Ok(())
}

#[tauri::command]
pub fn open_ad_link(app: tauri::AppHandle, url: String) {
    // Only web pages; never file:// or custom schemes.
    if url.starts_with("https://") || url.starts_with("http://") {
        let _ = app.opener().open_url(url, None::<String>);
    }
}

Window::add_child is behind Tauri’s unstable feature. Enable it on tauri in src-tauri/Cargo.toml: tauri = { version = "2", features = ["unstable"] }.

The webview runs this script in every frame. Ads render inside iframes, so each frame reports clicks and passes links up to your page, which opens them only right after a real click.

src-tauri/src/ads-init.js

// Runs in every frame of the ads webview.
const AD_PAGE_ORIGIN = "https://your-domain.com";
// How long after a click an ad may open its landing page.
const CLICK_WINDOW_MS = 1000;

// Your page (the top frame) opens a landing page only right after a real click.
if (window.top === window) {
  let lastClick = -Infinity;
  window.addEventListener("message", (event) => {
    if (event.data?.adClick) lastClick = performance.now();
    if (
      event.data?.adOpenUrl &&
      performance.now() - lastClick < CLICK_WINDOW_MS
    ) {
      lastClick = -Infinity;
      window.__TAURI_INTERNALS__?.invoke("open_ad_link", {
        url: event.data.adOpenUrl,
      });
    }
  });
}

// Every frame, ad iframes included, reports clicks and hands links to the
// top frame instead of navigating.
document.addEventListener(
  "click",
  (event) => {
    window.top.postMessage({ adClick: true }, AD_PAGE_ORIGIN);
    const link = event.target.closest?.("a");
    if (link?.href) {
      event.preventDefault();
      window.top.postMessage({ adOpenUrl: link.href }, AD_PAGE_ORIGIN);
    }
  },
  true,
);

window.open = (url) => {
  if (url) window.top.postMessage({ adOpenUrl: String(url) }, AD_PAGE_ORIGIN);
  return null;
};

src-tauri/src/main.rs

tauri::Builder::default()
    .plugin(tauri_plugin_opener::init())
    .invoke_handler(tauri::generate_handler![ads::open_ad_link])

Because the ad page is loaded from your domain (remote content), Tauri blocks it from calling commands unless a capability opts that origin in. Grant the ads webview only the one command it needs:

src-tauri/capabilities/ads.json

{
  "$schema": "../gen/schemas/remote-schema.json",
  "identifier": "ads",
  "webviews": ["ads"],
  "remote": { "urls": ["https://your-domain.com"] },
  "permissions": ["core:default", "allow-open-ad-link"]
}

Define that permission for your command:

src-tauri/permissions/open-ad-link.toml

[[permission]]
identifier = "allow-open-ad-link"
description = "Allow the ads webview to open an ad's landing page in the browser."
commands.allow = ["open_ad_link"]

On Windows, set the ads webview’s tracking prevention level to none: call ICoreWebView2Profile3::SetPreferredTrackingPreventionLevel with COREWEBVIEW2_TRACKING_PREVENTION_LEVEL_NONE through with_webview. WebView2 otherwise blocks the cookies bidders use to recognize returning users, which lowers bids.

Other frameworks

Meet the two requirements with your framework’s own APIs: set a standard browser User Agent on the webview, and send link clicks and window.open calls from ad frames to the system browser, only right after a real click. The Tauri example above shows the full pattern.

Building with a framework not listed here? It will work as long as it renders web content. Contact your RevIQ account manager if you need help with setup.

Get Started

Quickstart

Supported frameworks

Desktop requirements

Electron

Installation

Usage

Tauri

Other frameworks

​Supported frameworks

​Desktop requirements

​Electron

​Installation

​Usage

​Tauri

​Other frameworks

Supported frameworks

Desktop requirements

Electron

Installation

Usage

Tauri

Other frameworks