Chromium

Binaries 

Chromium binaries for each supported platform are located inside corresponding Fuzio JARs:

• fuzio-win32-2026.1.0.jar – Chromium binaries for Windows 32-bit.
• fuzio-win64-2026.1.0.jar – Chromium binaries for Windows 64-bit.
• fuzio-mac-2026.1.0.jar – Chromium binaries for macOS.
• fuzio-mac-arm-2026.1.0.jar – Chromium binaries for macOS Apple Silicon.
• fuzio-linux64-2026.1.0.jar for Linux 64-bit.
• fuzio-linux64-loong-2026.1.0.jar for Linux Loong 64-bit.
• fuzio-linux64-arm-2026.1.0.jar – Chromium binaries for Linux ARM 64-bit.

Location 

By default, Fuzio extracts Chromium binaries to the user’s temp directory on Linux and macOS, and to AppData\Local\Fuzio directory on Windows.

Here is how to change the directory where Fuzio will extract the binaries:

1. Using the fuzio.chromium.dir system property.

It can be done either by System.setProperty() method:

System.setProperty("fuzio.chromium.dir", "Users/Me/.fuzio");

System.setProperty("fuzio.chromium.dir", "Users/Me/.fuzio")

or through a JVM parameter:

-Dfuzio.chromium.dir="Users/Me/.fuzio"

2. Via the EngineOptions when constructing the Engine:

var engine = Engine.newInstance(
    EngineOptions.newBuilder(renderingMode)
            .chromiumDir(Paths.get("Users/Me/.fuzio"))
            .build()
);

val engine = Engine(renderingMode) {
chromiumDir = Path("Users/Me/.fuzio")
}

The directory path can be either relative or absolute.

Verification 

Each Fuzio version is compatible only with the same version of the binaries. For example, Fuzio 2026.1.0.1 will not work with the binaries from Fuzio 2026.1.0.

To make sure that the Chromium binaries are compatible with the current Fuzio version, the library verifies the binaries.

Extraction 

By default, Fuzio extracts binaries from a corresponding JAR file when Engine is first created. If you need to extract binaries earlier, use this code:

// Use the default directory.
ChromiumBinaries.deliverToDefaultDirectory();
// Or use an arbitrary directory.
ChromiumBinaries.deliverTo(Paths.get("/path/to/binaries"));

// Use the default directory.
ChromiumBinaries.deliverToDefaultDirectory()
// Or use an arbitrary directory.
ChromiumBinaries.deliverTo(Path("/path/to/binaries"))

If the compatible binaries are already extracted, Fuzio will not extract them again. Otherwise, Fuzio will extract the binaries again and override the existing files.

Custom delivery 

Developers can get the full control of delivering Chromium binaries to the environment. This capability is intended for advanced use cases, such as downloading binaries from the network, or using a custom compression algorithm.

To customize the delivery, implement BinariesDelivery interface and deliver the binaries when you need them:

class TuneBinaryDelivery implements BinariesDelivery {

    public void deliverTo(Path chromiumDir) {
        // Pseudocode:
        // Path downloadedArchive = SharedNetworkDrive.download("fuzio-win64.gz");
        // Gzip.extract(downloadedArchive, chromiumDir);
    }
}
...
// Use the default directory.
ChromiumBinaries.deliverToDefaultDirectory(new TuneBinaryDelivery());

// Or use an arbitrary directory.
ChromiumBinaries.deliverTo(chromiumDir, new TuneBinaryDelivery());

class TuneBinaryDelivery : BinariesDelivery {
    override fun deliverTo(chromiumDir: Path) {
        // Pseudocode:
        // Path downloadedArchive = SharedNetworkDrive.download("fuzio-win64.gz");
        // Gzip.extract(downloadedArchive, chromiumDir);
    }
}
...
// Use the default directory.
ChromiumBinaries.deliverToDefaultDirectory(TuneBinaryDelivery())

// Or use an arbitrary directory.
ChromiumBinaries.deliverTo(chromiumDir, TuneBinaryDelivery())

If the compatible binaries are already extracted, Fuzio will not call the custom delivery.

Sandbox 

Windows and macOS 

Fuzio supports Chromium Sandbox on Windows and macOS. Sandbox is enabled by default, but you can disable it via the appropriate Engine option:

var engine = Engine.newInstance(
        EngineOptions.newBuilder(renderingMode)
                .disableSandbox()
                .build()
);

val engine = Engine(renderingMode) {
    sandboxDisabled = true
}

Linux 

Chromium relies on user namespaces to sandbox subprocesses. When this feature is unavailable, Fuzio cannot start Chromium and throws a SandboxNotSupportedException during Engine initialization.

On Debian 10, user namespaces are disabled by default for unprivileged users. Ubuntu also supports toggling them through a kernel parameter. On these systems, you can enable user namespaces with:

sudo sysctl -w kernel.unprivileged_userns_clone=1
echo 'kernel.unprivileged_userns_clone=1' | sudo tee -a /etc/sysctl.d/99-enable-unprivileged-userns.conf

On Ubuntu 23.10 and later, user namespaces are further restricted by AppArmor. To relax this restriction configure the following parameter:

sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=0
echo 'kernel.apparmor_restrict_unprivileged_userns=0' | sudo tee -a /etc/sysctl.d/99-enable-unprivileged-userns.conf

Other Linux distributions enable user namespaces by default and do not require additional configuration.

If you are unable to modify the environment configuration to enable user namespaces, you can disable the Chromium sandbox. This approach significantly reduces security and should only be considered as a last resort.

Traffic 

Chromium is a complex software that consists of many components. Some components may perform background network activity for various purposes like sending statistic data, synchronization, optimization, data download, etc.

In this section we describe the components that might generate additional network traffic and explain how to disable them.

Optimization Guide Service 

This component represents a Chromium service from Google. It’s designed to help developers improve the app performance and efficiency. It provides tailored optimization advice and runtime configuration data based on a device’s specific hardware, software, and user habits. This service is especially essential when developing apps for Android. When started this service fetches the optimization models from a Google web service.

Fuzio disables this component, so it doesn’t fetch any data from the Google web service.

Spell checker 

By default, this component doesn’t send any requests to external web servers. It uses the local dictionaries to check the spelling. However, it may send requests to the Google web service to fetch the dictionaries for the languages that are not available locally.

If you don’t need the spell checker functionality, and you want to suppress any network activity related to it, you can disable the spell checker using the approach described in the Spell Checker guide.

Translate Ranker 

This component is used to determine whether a user should be given a translation prompt or not. Chromium downloads the ranker models required for language determination.

This component is disabled in Fuzio, so it doesn’t fetch any data from external web servers.

Media casting 

This component is responsible for media content casting to the media devices with Chromecast. When Chromium is started this component sends a multicast request in the local network to discover the devices available for casting.

By default, the Chromecast feature is disabled and no traffic is generated. The Chromecast feature can be enabled when initializing an Engine instance as described in the Media guide.

Component Updater 

This component is responsible for updating other components in Chromium. By default, it’s disabled. If you enable proprietary codecs, the component updater will be enabled automatically to update the corresponding internal components. When this component is enabled, you might see requests to https://update.googleapis.com/service/update2/json.

DNS Over HTTPS (DoH) 

DoH is the default DNS resolution protocol used in Chromium. Chromium checks whether the system DNS provider supports DoH and tries to recognize it. If the system DNS is configured to use Google Public DNS or another recognized provider that supports DoH, Chromium will automatically switch to that provider’s DoH service. Thus, Chromium will make requests to the trusted DoH servers such as google.dns to resolve DNS.

By default, DoH is enabled in Fuzio. If you want to disable it, use the following code:

var engine = Engine.newInstance(
        EngineOptions.newBuilder(renderingMode)
                .disableDnsOverHttps()
                .build()
);

When DoH is disabled, Chromium will use the unencrypted system DNS over UDP or TCP as configured by the operating system for DNS resolution