Skip to content
ParrotJS

Your Code, Live. Right in the Editor.

ParrotJS shows runtime values next to every expression as you type. Time travel through execution. Run inline tests. No more console.log, no terminal switching, no context breaks.

Get Started FreeRead the Docs

How It Works

See the same code, with and without ParrotJS.

Without ParrotJS
const value = compute(a, b);
console.log(value);
// switch to terminal, read, switch back
const result = transform(value);
console.log(result);
// switch again, forgot what you were doing
console.log("done");
→ 4 log lines, 3 context switches
With ParrotJS
example.js — ParrotJS
// live values appear inline as you type
const user = { name: "Ada", role: "dev" };→ {name: 'Ada', role: 'dev'}
const score = user.role === "dev" ? 100 : 0;→ 100
console.log(`Hi ${user.name} — score ${score}`);→ 'Hi Ada — score 100'(inline, no terminal)
score; // ? score→ 100
values update as you type·coverage

Everything Happens in the Editor

Stop the console.log → terminal → edit → repeat loop. See values, run tests, and debug — all inline.

📌

Inline Runtime Values

Every variable, function return, and loop iteration shows its value inline as you type. No console.log needed. Values update continuously as your code changes.

💬

Live Comments

Drop // ? after any expression to display its value. Works inside deeply nested loops, conditionals, and callbacks.

Live Feedback

📌

Inline Runtime Values

Variables, returns, and loop iterations show values inline as you type. Sticky values persist across edits.

💬

Live Comments

Drop // ? after any expression to display its value. Works in nested loops and callbacks.

🖥️

Console in Your Editor

console.log output appears inline at the call site. Sidebar panel streams all entries.

✅

Inline Test Runner

expect() assertions inline. Green ✓ for pass, ✗ for fail. No test config needed.

🧲

Sticky Values

Values persist across edits as dimmed annotations until fresh results replace them.

🎯

Selection Evaluation

Select any expression and see its runtime value immediately as a temporary inline decoration.

Debug & Inspect

⏱️

Time Travel Debugging

Record execution step-by-step, then scrub through it like a video. Navigate forward, backward, step-into, step-out, step-over — with a visual timeline panel color-coded by function.

📌

Pin & Compare

Pin a snapshot and compare side-by-side with live results. Highlights what changed.

🔍

Value Explorer

Interactive tree view for objects, Maps, Sets, Promises, and circular references.

🖱️

Hover Inspection

Hover any variable for a formatted deep-inspect view with copy, tree view, and text view actions.

👁️

Watch Expressions

Add any expression as a watch and track its value across executions from the sidebar.

📊

Code Coverage

Green/gray/red gutter dots show exactly which lines executed and which didn't.

Project Setup

📘

Zero-Config TypeScript

JS, TS, JSX, TSX work out of the box. Picks up tsconfig.json automatically.

📦

Full Module Resolution

Handles path aliases, barrel files, dynamic imports, JSON imports, and monorepo workspaces.

▶️

Three Run Modes

Run automatically as you type (debounced), on save, or on demand.

⚙️

Configuration Profiles

Pre-configured profiles for Node, React, and vanilla JS projects with sensible defaults.

🛡️

Execution Safety

Each file runs in a forked Node.js child process with a configurable timeout. User code can't crash the IDE.

🎨

Theme Aware

Time-travel color palettes and decorations adapt to light/dark VS Code themes.

Simple, Transparent Pricing

Start free forever. Upgrade to PRO when you want Time Travel, coverage, and the full toolkit.

Free

$0forever

Everything you need to see your code run. Install, open a file, and start typing.

  • Inline runtime values
  • Live comments (// ?)
  • Inline console.log output
  • Inline expect() assertions
  • Sticky values
  • Run modes (auto, on save, on demand)
  • TypeScript, JSX, TSX & ESM support
  • Configuration profiles
  • Process-isolated sandbox
Install Free
Popular

PRO

$20one-time

Time Travel, code coverage, hover inspection, the Value Explorer, and more. One-time payment, yours forever.

  • Everything in Free
  • 30-day free trial of all PRO features
  • Time Travel debugging
  • Code coverage indicators
  • Auto-log & line values
  • Hover tooltips & deep inspection
  • Value Explorer
  • Watch expressions
  • Test results panel
Get PRO — $20
Free 30-day trial

Try PRO free for 30 days — no credit card, no risk.

Unlocks every feature instantly. Request it from inside the extension.

Install Free

FREE vs PRO — Feature Comparison

See exactly what you get at every tier.

FeatureFreePRO
Inline runtime values
Live comments (// ?)
Inline console.log output
Inline expect() assertions
Sticky values
Run modes (auto, on save, on demand)
TypeScript, JSX, TSX & ESM
Configuration profiles
Process-isolated sandbox
Auto-log & line values—
Hover tooltips & deep inspection—
Time Travel debugging—
Code coverage indicators—
Value Explorer (graph)—
Watch expressions—
Test results panel—

Frequently Asked Questions

Everything you need to know about ParrotJS.

What exactly is ParrotJS?
ParrotJS is a VS Code extension that shows runtime values inline in your editor as you type. Instead of console.log → switch to terminal → read → switch back → remove logs, you see values right next to every expression — continuously updated, no switching needed. It also includes time travel debugging (scrub through execution like a video), inline test assertions, code coverage visualization, and a value explorer for deep object inspection.
How is this different from a debugger?
Debuggers require breakpoints, manual stepping, and switching between editor and debug panels. ParrotJS shows values inline, automatically, as you type. Time Travel lets you record execution and scrub backward — something traditional step-through debuggers can't do. And you never leave the editor window.
Does it work with frameworks like React, Next.js, Vue?
ParrotJS operates at the JavaScript/TypeScript runtime level, so it works with any project that runs in Node.js. JSX and TSX are transpiled automatically. It also ships with pre-configured profiles for React, Node, and vanilla JS projects with sensible defaults for each.
Is my code sent anywhere? Does it need a network connection?
No. ParrotJS runs entirely locally. Each file executes in a forked Node.js child process with process isolation — user code can't crash the IDE. No telemetry, no cloud processing. The only network call is license validation for PRO, which happens once a day.
What's included in the Free tier?
The Free tier is free forever and includes inline runtime values, // ? live comments, inline console.log output, inline expect() assertions, sticky values, all three run modes, TypeScript/JSX/TSX/ESM support, configuration profiles, and the process-isolated sandbox. Install it and start seeing your code run in under two minutes.
What does PRO unlock?
PRO adds Time Travel debugging with the visual timeline, code coverage indicators, auto-log and line values, hover tooltips with deep inspection, the Value Explorer, watch expressions, and the test results panel. It's a one-time payment of $20 (₹2,000) and yours forever — including a full year of updates.
Is there a free trial?
Yes. You can request a 30-day free trial from inside the extension (ParrotJS: Request Free Trial) — it emails a trial license key that unlocks all PRO features for 30 days. One trial per machine.
How do I buy PRO?
Click "Get PRO" on this page or run ParrotJS: Purchase PRO inside VS Code. You'll complete checkout through Lemon Squeezy (cards and PayPal accepted, local pricing available in INR). Your license key is emailed to you — paste it into ParrotJS: Enter License Key to activate.
Does the license cover updates?
A PRO purchase is a perpetual license and includes updates for one year from the release date. After that, your license continues to work and you can keep using the version you have.
How does Time Travel work?
When you enable recording, ParrotJS instruments your code to capture every expression's value at every execution step. You can then scrub through the timeline (like a video), navigate statement-by-statement forward or backward, step into/out/over functions, and pin snapshots to compare side-by-side with live results. If you edit the code, the trace is marked as stale.
What are Live Comments?
Type // ? after any expression and its runtime value displays inline. Works in deeply nested loops, conditionals, and callbacks. No boilerplate — just two characters. You can also toggle Auto Log Mode to automatically show values for all meaningful expressions without adding any markers.
How do inline tests work?
Write expect() assertions anywhere in your code — expect(x).toBe(5), .toEqual(), .toContain(), .toThrow(), and more. Passing assertions show a green ✓ at the line. Failures show ✗ with the actual vs expected mismatch. No test framework configuration needed. The status bar shows pass/fail counts (e.g. 2✓ 1✗).
Does it handle large objects without freezing?
Yes. The Value Explorer uses lazy loading — object children load on click via IPC to the runtime, so expanding a 10,000-entry object won't hang. It handles Maps, Sets, Dates, Promises, TypedArrays, and circular references correctly.
What about TypeScript source maps?
ParrotJS uses a 4-stage source map chain (original → transpiled → bundled → instrumented) so every inline value, error, and coverage marker maps back to the correct original TypeScript source line — not the compiled output.

Stop Switching. Start Seeing Your Code Run.

Install ParrotJS free and see runtime values inline in under two minutes. Then try every PRO feature free for 30 days — no credit card, no account needed.

Install from Marketplace