Trying Out Rustwright: A Rust-Based Alternative to Playwright

If you run large browser automation suites, you know that scaling Playwright can get expensive. Standard Playwright relies on a Node.js driver subprocess to translate your Python or Node commands into browser actions.

Rustwright is an experimental, open-source project by the team at Skyvern. It keeps the Playwright API you are familiar with but replaces the heavy Node driver with a native Rust engine that speaks raw Chrome DevTools Protocol (CDP) directly to Chromium.

Because the project is currently in alpha, you should not deploy it to production yet. However, the performance claims—faster execution and up to 70% less memory usage—make it a tool worth trying out and validating in a local test environment.

What Is It?

Rustwright is an early-stage, Chromium-only browser automation library.

Instead of spawning a separate Node.js process to control the browser, Rustwright runs an asynchronous CDP engine written in Rust directly within your runner process. No Node driver, with no Playwright automation fingerprint which makes it almost 2.55x faster.

Why You Should Experiment With It

While it is too early to migrate your enterprise pipelines, running a local proof-of-concept (PoC) with Rustwright lets you evaluate its core features:

• Resource Usage: By removing the Node.js translation layer, local test runs should show reduced CPU and memory spikes.
• CDP-First Inputs: Rustwright routes events like clicks and typing through native CDP input events (Input.dispatchMouseEvent). This behaves more like a real hardware interaction compared to standard synthetic JavaScript events.
• API Compatibility: The library uses the same syntax as Playwright. You can test your existing scripts by changing only the import statements.

Prerequisites

To set up a local validation test, you need Python version 3.8 or newer

Local Installation & Setup

You can install the experimental package directly from PyPI.

pip install rustwright

After installation, download the compatible Chromium browser binary:

python -m rustwright install chromium

Writing a Validation Script

Here is a simple script to verify if Rustwright can successfully navigate, handle inputs, and assert elements on a target page. It’s also available in the QAClub GitHub repo.

import os
from rustwright.sync_api import sync_playwright

def run_validation_test():
    print("[INFO] Starting Rustwright engine...")
    with sync_playwright() as p:
        # Launch Chromium (Rustwright is currently Chromium-only)
        browser = p.chromium.launch(
            headless=True,
            args=["--no-sandbox"]
        )
        
        context = browser.new_context(viewport={"width": 1280, "height": 720})
        page = context.new_page()

        print("[INFO] Navigating to login page...")
        page.goto("https://the-internet.herokuapp.com/login")

        # Fill inputs using native CDP events
        page.locator("input#username").fill("tomsmith")
        page.locator("input#password").fill("SuperSecretPassword!")
        
        print("[INFO] Submitting form...")
        page.locator("button[type='submit']").click()

        # Wait for the success banner
        page.wait_for_selector(".flash.success")
        
        # Verify the element is visible
        is_logged_in = page.locator(".flash.success").is_visible()
        print(f"[RESULT] Login successful: {is_logged_in}")

        # Capture a screenshot to verify rendering
        page.screenshot(path="rustwright_test.png")

        context.close()
        browser.close()

if __name__ == "__main__":
    run_validation_test()

Run the Script

Execute the script in your terminal to see if the engine initializes correctly on your machine:

python test_rustwright.py

Limitations to Keep in Mind

Since Rustwright is in an early alpha phase, expect to run into limitations during your testing:

• Chromium Only: There is no support for Firefox or WebKit.
• Incomplete API Coverage: While the core locator, navigation, and page APIs work, complex Playwright features (like advanced network interception or heavy multi-context setups) are still being ported.
• Stability: You will likely encounter unhandled exceptions or edge-case bugs that do not exist in stable Playwright.

Verdict: Worth a Look, Not Ready for Production

Rustwright is a promising concept for teams looking to optimize resource-heavy automation suites in the future.

Do not replace your existing test suites with it today. Instead, run a small pilot with a few of your standard test cases to see how the execution speed and resource consumption compare to standard Playwright on your local hardware.