What is Trq?

Trq is pronounced “torque”.

Perform a browser flow once. Trq records it, then replays it as a deterministic test — forever.

Trq is an IDE-style desktop studio for browser testing. You open the app, drive a real bundled browser like a normal user — click, type, upload, navigate, assert — and Trq captures every step. Press Play and it replays the whole flow exactly, from a clean slate, as many times as you want. No test code, no framework to learn, no drivers to install, no separate browser download, no CI plumbing just to run your first test.

Perform, don’t program

Most testing tools hand you a programming API and ask you to describe — in code — what a user does: find this element, click it, wait for that, assert the other. You write it, you maintain it, and you babysit it when the app changes.

Trq inverts that. You do the thing once in a real browser. Trq watches and records every click, keystroke, file upload, navigation, and assertion as a structured, editable session — then re-drives those exact steps on demand. The recording is the test. There’s nothing to script, and nothing to keep in sync with a separate codebase.

What makes Trq different

Recorders aren’t new — but most are toys that produce brittle scripts you immediately have to fix by hand. Trq is a full testing studio built record-first, with the engine to make recordings hold up:

• 🧬 Selectors that self-heal. Other tools pin each step to a single selector — rename a class or re-order the DOM and the test breaks. Trq saves every element as a ranked ladder of selectors (accessible name, test-ids, visible text, semantic class, scoped CSS, and more) and resolves the first confident match, falling back automatically. Framework noise (generated ids, hashed CSS-module classes) is filtered out so the stable rungs survive redesigns.

• 🔁 Deterministic, isolated runs. Every Play clears cookies, storage, and caches first, then replays from step 1. No leftover state, no order-dependence, no “works on my machine” — the same result every run, on every machine.

• 🩹 Fix failures in a click. When a step can’t resolve, Trq re-scores candidates from the live page and Pick from page captures a fresh selector by pointing. A built-in inspector grades each selector stable / brittle / dynamic so you catch fragile ones before they break.

• ♻️ Reusable building blocks. Call one .trq from another (nested flows), so a login or setup lives in exactly one place — fix it once, every caller updates. Branch a shared prefix into a new test, Resume to extend from the end, or insert steps in the middle — all without re-recording.

• ✓ Assert & capture by pointing. Check that an element is visible, or that its text/value matches (exact, contains, or regex) — just click it. Capture a value from the page into {{var.NAME}} and reuse it downstream; only the instruction is saved, never the value, so it always reflects the current run.

• ⚡ A full API client, inside your test. Call an HTTP endpoint mid-flow with a builder for method, URL, params, headers and JSON body — all templatable. It runs server-side (no cross-origin limits) and can fire before any page loads, e.g. to fetch the URL you then navigate to. Extract response values into variables; import a request from a copied cURL command.

• 🌐 Deterministic network mocking. Snapshot API responses while recording and serve them back on replay — fast, offline-capable, repeatable. Edit any response (flip a 200 to a 500) to exercise error paths you can’t trigger on demand. Static assets still load live; only API calls are mocked.

• 🔎 Inspect & share every run. After each replay the bottom panel fills with Events, Console, Network, Summary, Timeline, and a live Elements tree. Export the whole run — steps, screenshots, console, and network — as one self-contained HTML file anyone can open, no install required.

How that compares

	Typical browser-testing tools	Trq
Authoring	Write & maintain code	Perform the flow once
Selectors	One selector per step; breaks on a redesign	Ranked ladder that self-heals
State between runs	You manage setup & teardown	Cleared automatically every run
Setup	Install runners, drivers, browsers, wire up CI	One desktop app, browser bundled in
API calls & mocks	Bolt on separate tools	Built in
A failing step	Dig through logs, edit code, re-run	Re-scored selectors + Pick from page
Output	Log files & CI artifacts	Live panels + a shareable HTML report

The result: maintenance stays linear as your suite grows, instead of compounding every time the UI shifts.

Core concepts

• Session — one recorded flow, stored as a single .trq bundle (the events, config, and metadata). This is your “test”.
• Project — any folder that holds .trq sessions. Open a folder in Studio and every session in it shows up in the sidebar; organize them in sub-folders as suites.
• Studio — the desktop app where you record, edit, replay, and debug. You perform a flow once; Trq turns it into a repeatable test.
• Deterministic replay — every Play/Resume clears the browser’s cookies, storage, and caches first, then replays from step 1, so runs never depend on leftover state.

Ready?

Install Trq, then record your first test — you’ll go from an empty folder to a recorded, replayable test in about a minute.