Skip to main content
Native Selenium, Playwright, Appium, REST Assured, CLI, database, and reporting support

One Java engine for web, mobile, API, database, and CLI automation.

Keep direct Selenium WebDriver, Microsoft Playwright, Appium, and REST Assured control. If your stack is browser-only, a focused Playwright path can be best. Add SHAFT when your program needs Java orchestration across web, native mobile, API, database/CLI checks, and shared evidence.

Generate a runnable projectRead quick start
Selenium WebDriverPlaywright browserAppium native mobileREST Assured APIDatabase / CLISelenium GridAllure + visual reportsTestNG / JUnitCucumber BDDMCP agents
Maven CentralSelenium ecosystemGoogle Open Source award
Native engines, one suiteCompare surfaces
Web GUISelenium WebDriverNative mobile GUIAppiumAPI testingREST Assured
SHAFT.GUI.WebDriver driver = new SHAFT.GUI.WebDriver();

driver.browser().navigateToURL("https://duckduckgo.com/")
  .and().element().type(By.name("q"), "SHAFT Engine")
  .and().assertThat().title().contains("DuckDuckGo");
  1. Generate a project from installation docs.
  2. Run the quick start and validate one passing web flow.
  3. Add native mobile, API, DB, and CLI checks using the same framework controls.
  4. Enable MCP only after evidence review, then tighten prompts and approval policy.
A central automation engine connected to browser, mobile, API, terminal, and reporting interfaces
For skeptical automation engineers

SHAFT is not a wrapper that hides the real tools.​

It keeps the battle-tested engines underneath and removes the repeated work that makes large Selenium suites expensive to maintain.

Choose SHAFT whenYour Java suite spans WebDriver, native mobile GUI, API, DB, CLI, Grid, or BDD.
Keep direct controlRaw Selenium, Appium, and REST Assured APIs remain available.
Reduce suite taxSynchronization, evidence, smart locators, and diagnostics move into the engine.
Beyond browser-onlyNative mobile GUI and API checks share the same lifecycle, validation, and Allure evidence as web UI.
Native APIs stay availableUse Selenium By, WebDriver, Appium locators, touch actions, SHAFT.API over REST Assured, TestNG, JUnit, and Cucumber when direct control matters.Technology mapFlake causes are handled in the engineSynchronized GUI actions, smart locators, screenshots, logs, and Allure steps target the wait and locator churn raw Selenium or Appium leaves to every test.Feature mapDebugging starts with evidenceWeb, mobile, API, CLI, and database actions can become structured Allure evidence, then Doctor and Heal can classify failures and propose recovery paths.Reporting guide
Start narrow, keep the expansion path

Web, native mobile GUI, and API checks share one spine.​

Selenium and Playwright focus the browser conversation. SHAFT is stronger when the product also needs native mobile screens, service checks, remote execution, and one evidence trail.

SHAFT Engineshared lifecycle, validation, configuration, and evidence
Web GUISelenium WebDriver / PlaywrightSynchronized browser actions, smart locators, screenshots, traces, and Allure evidence.Native mobile GUIAppiumAndroid, iOS, mobile web, Flutter, real devices, emulators, and cloud devices.API testingREST AssuredRequests, authentication, extraction, schemas, and response assertions in one report.
Selenium Grid remote executionAllure screenshots, logs, requests, and responsesFluent design with TestNG, JUnit, and Cucumber BDDDoctor, Heal, and MCP tools for AI-assisted triage
Web GUISelenium sessions with synchronized W3C WebDriver actions, smart locators, screenshots, and reports.Open guideMobile GUINative Appium workflows for Android, iOS, mobile web, Flutter, and cloud devices through the same GUI facade.Open guideAPIREST Assured requests, extraction, schemas, authentication, and response validation in the same report.Open guideCLILocal, Docker, SSH, and file-system actions with attached evidence.Open guideDatabaseJDBC connections, queries, updates, and result validation.Open guide
The honest comparison

Choose tools by scope: browser-only suites can stay in Playwright; SHAFT fits Java suites that must span multiple surfaces.

The value is keeping native automation power while standardizing synchronization, evidence, design, and recovery when one team owns web, mobile, API, and DB/CLI coverage together.

Native Selenium

Critic view: Direct control, but synchronization, reporting, screenshots, Grid config, mobile handoff, API setup, and triage can remain in suite code.

SHAFT fit when: Same WebDriver/Grid/Appium control, plus synchronized actions, REST Assured API flows, fluent validations, smart locators, and Allure evidence.

Microsoft Playwright

Critic view: Great for browser-only Node/TypeScript suites with traces, codegen, and web-first assertions.

SHAFT fit when: A strong option when your suite needs to keep Java/WebDriver, native mobile Appium, REST Assured APIs, DB/CLI checks, BDD, and deterministic reporting together.

Long-term suite design

Critic view: Single-surface tools age well until mobile, API setup, cloud devices, reports, and business-readable flows arrive.

SHAFT fit when: One fluent design and evidence model can scale from a web smoke test to cross-surface TestNG, JUnit, and Cucumber suites.

Smart locatorsSelenium GridFluent designBDD with Cucumber
What happens when the app fights back

Act, validate, report, diagnose, recover.

A flaky click should not send the team spelunking through console logs. SHAFT turns the test path into reviewable evidence.

IntentSmart locatorSynchronized W3C actionValidationAllure evidenceDoctor or Heal
Less wait code in tests

Synchronized actions keep timing policy in the engine instead of scattered across every test class.

More signal when a run fails

Allure steps, screenshots, logs, API responses, command evidence, and Doctor analysis tell the failure story.

Scale without switching engines

Run locally, in CI, on Selenium Grid, Appium, cloud providers, and BDD suites with the same facade.

AI-native after the fundamentals are solid

Connect shaft-mcp to your application.

SHAFT MCP exposes browser, Capture, Doctor, and Heal operations while the client retains its own model credentials and approval policy. The agent gets real automation tools; the framework keeps deterministic evidence.

MCP setupDiagnose with DoctorRecover with Heal
Show install commands

Execute these commands only after your security team approves runtime-script execution for your environment. Prefer manual configuration for production, high-security, or air-gapped contexts. Verify command output before you grant any approval prompts. A selected MCP client, network access, and compatible desktop platform are required. The command bootstraps Python and Java only when missing, then installs shaft-mcp from this repository's release script flow.

Codex CLI / IDEGlobal Codex configuration
curl -fsSL https://raw.githubusercontent.com/ShaftHQ/SHAFT_ENGINE/main/scripts/mcp/install-shaft-mcp.sh | sh -s -- --codex
Claude CodeUser-scope MCP server
curl -fsSL https://raw.githubusercontent.com/ShaftHQ/SHAFT_ENGINE/main/scripts/mcp/install-shaft-mcp.sh | sh -s -- --claude
Claude DesktopLocal desktop MCP server
curl -fsSL https://raw.githubusercontent.com/ShaftHQ/SHAFT_ENGINE/main/scripts/mcp/install-shaft-mcp.sh | sh -s -- --claude-desktop
GitHub Copilot CLIUser-level Copilot configuration
curl -fsSL https://raw.githubusercontent.com/ShaftHQ/SHAFT_ENGINE/main/scripts/mcp/install-shaft-mcp.sh | sh -s -- --copilot
GitHub Copilot in IntelliJ IDEAJetBrains MCP configuration
curl -fsSL https://raw.githubusercontent.com/ShaftHQ/SHAFT_ENGINE/main/scripts/mcp/install-shaft-mcp.sh | sh -s -- --copilot-intellij

Need to inspect or edit the configuration yourself? Open the manual configuration guide.

Start with native Selenium power. Keep the suite maintainable.

Fastest path: install, generate a runnable project, run the quick start, then wire MCP only if you need AI-agent operations.

Generate a runnable projectRead quick startConnect your AI agent