JSCR — JavaScript AI-Powered Code Runner

Live inline JavaScript & TypeScript execution inside VS Code.
Type code, see results — no button presses, no terminal switching, no context loss.

 Enjoying JSCR? Buy me a coffee — it keeps the updates coming.

Why JSCR

• Live inline evaluation — every top-level expression is reported next to its line, in real time.
• File Mode — runs the active .js / .ts file against your workspace's node_modules. No config.
• Scratch Mode — persistent scratchpad snippets that survive restarts, kept in ~/.jscr/snippets/.
• Dormant when off — zero background processes when the panel is closed.
• AI-assisted fixes — send a runtime error + code to OpenRouter and preview a two-column diff before accepting.
• Theme-native output — panel colors are pulled from your active VS Code color theme, not hardcoded.
• Polyglot — first-class Python, Java, Go, Rust, C#, C++, Ruby and Groovy alongside JS/TS, each running live.

Polyglot: Python, Java, Go, Rust, C#, C++, Ruby & Groovy

JSCR also runs Python, Java, Go, Rust, C#, C++, Ruby and Groovy snippets live, streaming their output into the same panel. Each language's toolchain is auto-detected on startup (results are cached, so subsequent launches are instant); a language only appears in the New Snippet menu when a supported toolchain is found.

• Package install? ✅ means JSCR can fetch a missing third-party dependency for that language on demand (into an isolated ~/.jscr store) — see Missing packages, installed on demand. Only C++ has no one-click installer (drop headers in manually); it still runs fine.
• Below the minimum? If a detected toolchain is older than the minimum, that language is treated as unavailable — running such a snippet shows a clear "version too old" message (just like an unsupported Node version) while every other language keeps working.
• Compiled languages run live too — Go, Java, Rust, C# and C++ re-compile+run on an idle debounce (never mid-keystroke). Turn this off per language with jscr.<lang>.liveMode (e.g. jscr.rust.liveMode) to run them only on demand.
• Timeouts — native runs get a longer default (jscr.process.timeoutMs, 45 s) than the in-vm JS engine, and the whole process tree is force-killed (SIGTERM → SIGKILL) on timeout so worker threads never linger.

Missing packages, installed on demand

When a run fails on a missing third-party dependency, JSCR surfaces an inline "install?" banner in the panel. Accept it and JSCR fetches just that package into an isolated store under ~/.jscr (never your system packages), then re-runs — so if more are missing, the next one surfaces, one at a time. Supported per language:

An import has no deterministic Maven coordinate, so Java and Groovy resolve it automatically — one Install click maps the failing import to a coordinate (a curated map of common libraries, then a Maven Central class search), no prompt. Java fetches via Coursier (run with the JDK you already have, or a cs/coursier on PATH — jscr.java.coursierPath to override); Groovy via Grape. C# maps a CS0246 error's using namespace straight to the NuGet id. C++ has no package-install flow (drop headers into ~/.jscr/cpp/include manually).

Version selector. Every install banner has an editable Version box, defaulting to latest — click Install to take the newest, or type a version to pin it (e.g. okhttp's 5.x main jar is a thin aggregator that won't compile, so pin 4.12.0). It threads through each ecosystem (name==ver for pip, name@ver for npm/cargo, -v ver for gem/NuGet, the coordinate version for Maven/Coursier). Dismiss re-runs the snippet so the panel refreshes after you resolve a dependency by hand.

Install Troubleshooter. When an install fails, every banner shows a Troubleshoot button (left of Dismiss/Install). It runs a safe, diagnostic-first sequence — is the package manager present? is the ~/.jscr store writable? is the registry reachable? — then a clean reinstall, classifies the failure into a likely cause (deprecated / moved / removed / renamed, version conflict, corrupt download, native-build needs a compiler, permissions), and shows the exact manual command. For Java/Groovy it adds a last-resort direct jar download from Maven Central straight into the classpath overlay (the "curl -O into lib"). The report stays on screen until you Dismiss or Retry (with a version box), so you can read every check — every remedy stays inside JSCR's own store, and a Copy diagnostics button copies the full report.

While a package is fetched — or a compiled language is building, or Groovy is resolving @Grab — the panel shows a status line (Groovy lists the exact @Grab coordinates it's downloading) so a slow first run never sits blank with no explanation.

Declaring packages inline (C# & Groovy). Instead of the banner you can pin dependencies in the snippet itself, and JSCR runs it as-is:

• C# — #r "nuget: Newtonsoft.Json, 13.0.3" (or .NET 10's #:package Newtonsoft.Json@13.0.3). JSCR lifts these into the project's <PackageReference>s. Script-style layout (top-level statements after class/record declarations) is auto-normalized so it compiles as a program, with your statement line numbers preserved.
• Groovy — the native @Grab('group:artifact:version') annotation, resolved into ~/.jscr/groovy/grape.

Program Input (stdin)

For interactive-looking programs — Java Scanner, Python input(), Go fmt.Scan — the panel has a Program Input box (toggle it from the header's terminal-prompt icon). Type the input your program reads ahead of time, one value per line, with one-click Paste and Clear:

Alice
30

On each run JSCR feeds that into the program's stdin and then closes it. So a read past what you supplied instantly hits end-of-input (Java NoSuchElementException, Python EOFError, Go io.EOF) with a red squiggle on that line — the re-run never hangs waiting for a human. Fill the box → every line runs each cycle. Leave it short → it fails fast at the first unsatisfied read. Input is remembered per snippet.

Requirements

• VS Code 1.85+
• Node.js v17+ (recommended v22 LTS for full ES2023 support)
• Optional, only for their languages: Python 3.7+, Java (JDK) 11+, Go 1.11+ on your PATH (or point JSCR at them with jscr.python.path / jscr.java.path / jscr.go.path).

Install

Marketplace (recommended): Extensions view → search JSCR → Install.

From a local .vsix:

code --install-extension jscr-<version>.vsix

Build a local .vsix yourself with npm run package — see docs/LOCAL_BUILD_AND_USE.md.

Quick start

1. Press Ctrl+Shift+J (macOS: Cmd+Shift+J) to open the JSCR panel.
2. Open any .js or .ts file — or press Ctrl+Shift+N to create a Scratch snippet.
3. Type. Each 300 ms of idle triggers a run.
4. Per-line results appear inline in the panel:

L 3   const total = 42          →  42
L 4   users.map(u => u.name)    →  ['ada', 'grace', 'linus']
L 5   console.log('hi', 3)      →  hi  3

Commands

All commands are available from the Command Palette — press Ctrl+Shift+P (macOS: Cmd+Shift+P) and type JSCR. Fix with AI is also on the editor right-click menu for .js/.ts files.

Configuration

Search jscr in Settings, or edit .vscode/settings.json:

Runtime-aware AI

Static editor-AI (Copilot, Cursor, …) reads your code. JSCR's AI reads your code and its actual run — real per-line values, real errors, real stdout, real timing across all ten languages — so every feature below is grounded in what your program did, not what a model guessed. Bring your own OpenRouter key (jscr.openRouterApiKey); the default free model works out of the box.

JSCR Assist — the master switch

JSCR: Assist (default ON) is the circuit breaker for every AI feature. Toggle it off and all AI is disabled and hidden from the menus, any on-screen AI card is dismissed, and native autocomplete/inline-suggestions for JSCR languages are suppressed too — one switch, nothing lingers. Toggle it from the JSCR Snippets view's sparkle icon or JSCR: Toggle Assist. There is exactly one code path to the model, so "Assist off ⇒ AI off" is a structural guarantee.

The AI toolkit — 15 features + Practice with AI

All are on every language unless noted, and each is invocable from the editor right-click menu (JSCR group) or the Command Palette.

① Understand a run

• Error Tutor — JSCR: Explain Error (AI) — a plain-language explanation of why your code broke (teaching the misconception, never just a patch); becomes a quick code review when there's no error. When: a crash you don't understand.
• Explain This Value — JSCR: Explain This Value (AI) — why one line produced the value it did, traced through the actual runtime values from this run. Click an inline result, or run it on the cursor line. When: an unexpected value and you want the real data-flow story.
• Semantic Output Diff — JSCR: Explain Output Change (AI) — explains, in meaning not bytes, why the output changed between your last two runs — tying it to your edit, or flagging nondeterminism when the code is unchanged. When: "why is it printing something different now?"
• AI Program Input — JSCR: Generate Program Input (AI) — reads what your program reads from stdin and generates a typical input plus an edge-case one, dropped straight into the Program Input box. When: a program that reads input and you don't want to hand-craft it.

② Change code — with proof

• Fix with AI — JSCR: Fix with AI — sends your code + the captured error and previews a two-column accept/reject diff before a single character changes. When: a runtime error you want fixed reviewably.
• Performance A/B Lab — JSCR: Performance A/B Lab (AI) — the AI proposes a faster version; JSCR runs both and shows measured timings, a behavioral-equivalence verdict (outputs actually compared), and an apply-able diff. When: "is this genuinely faster, and does it still behave the same?"
• Freeze Behavior as Tests — JSCR: Freeze Behavior as Tests (AI) — turns the snippet's current observed output into an idiomatic test file (Jest / pytest / JUnit / go test / …). When: lock in today's behavior before a refactor.
• Self-Repairing Snippet — JSCR: Self-Repairing Snippet (AI) — describe a goal in plain language; the AI writes it, JSCR runs it, and feeds the real error back to fix-and-retry until it runs cleanly. When: you want code that did run, not code that merely looks right.
• Verified Translation — JSCR: Verified Translation (AI) — translate a snippet to another language, run both and diff their outputs, retrying until they match — then it's saved as a runnable snippet, so it runs immediately. When: porting logic and needing proof it's equivalent.

③ Always-on guards (also fire automatically after each run; see jscr.ai.continuousChecks)

• Intent Comments — JSCR: Check Intent Comments (AI) — annotate a line with //? (or #? in Python/Ruby) stating what it should do — e.g. total = a + b //? should equal 42 — and JSCR compares that against the real output, flagging contradictions inline. When: encode an assumption and be told the moment reality disagrees.
• Surprise Detector — JSCR: Detect Surprises (AI) — flags outputs you most likely didn't intend (NaN, blank-where-data-expected, a swallowed error, an off-by-one count). When: catch quiet wrongness you'd otherwise scroll right past.
• Explain Flakiness — JSCR: Explain Flakiness (AI) — runs the snippet N times on the same input and, if results diverge, names the concrete source of nondeterminism (unseeded RNG, time, map/hash ordering, races, …). When: "sometimes it passes, sometimes it doesn't."
• Hunt Counterexample — JSCR: Hunt Counterexample (AI) — fuzzes your stdin to find one input that breaks it (crash / exception / timeout) and loads it into Program Input so it reproduces live. When: find the edge case before your users do.
• Minimize Repro — JSCR: Minimize Repro (AI) — shrinks a failing input to the smallest slice that still reproduces the same failure (delta debugging, real runs as the oracle), and explains why. When: a big failing input you want reduced to its essence.

④ Investigate & verify

• Hallucination-Proof API Probes — JSCR: Probe API (AI) — writes a tiny probe that exercises a real, installed library and runs it, answering strictly from what actually happened — so it can't hallucinate an API that doesn't exist. All ten languages, including Rust, Java and C++. When: "does this method exist / what does it actually return for an empty input?"
• Execution Time-Travel + AI Blame — JSCR: Time-Travel & AI Blame (AI) — JSCR keeps a rolling history of a snippet's past runs; step back through them, and AI Blame attributes the current result to the exact run that introduced it. When: "which change made the output flip — and when?"

⑤ Learn interactively

• Practice with AI — JSCR: Practice with AI — turns any snippet into a per-snippet coding tutor. Right-click → Practice with AI, then pick a difficulty (Easier / Medium / Hard / Complex) and an answer mode:

  • Written Answer — the AI writes a complete, runnable starter into the snippet (problem-as-comments + the language's boilerplate so it compiles as-is) and drops your cursor at the spot to complete. Write + run as usual, then a floating, draggable Submit Answer button sends your code + its real run output to the AI for grading.
  • Multiple Choice and Fill in the Blanks — answered in a swapped-in "JSCR Live Practice with AI" pane and graded locally against the AI's answer key (instant, no extra request).

  Questions render as formatted, syntax-highlighted code in a modern bottom-drawer UI; grading shows a 👍/👎 flash plus a result banner with the explanation and a Next question → button (advance is manual, so you read the feedback first — a wrong answer stays put to retry, or Skip). Run a session of N questions (2…50) or an endless stream (∞), ending in a pass / fail / skip dashboard with your passing rate and Restart / Close. A pinnable Info Pane shows the current hint + expected output. Works on all languages plus unknown file types, and is gated by JSCR Assist like every other AI feature. When: drill a language, library, or concept with instant, run-grounded feedback. See docs/AI_FEATURES.md.

Fix with AI — step by step

Uses OpenRouter — bring your own API key.

1. Get a key at openrouter.ai and paste it into jscr.openRouterApiKey.
2. Open a .js / .ts file with a runtime error.
3. Run it once so JSCR captures the error (a red squiggle marks the failing line).
4. Command palette → JSCR: Fix with AI, or right-click the file → JSCR: Fix with AI.
5. Review the side-by-side diff → Accept Fix or Reject.

Choosing a model

Run JSCR: Switch AI Model (OpenRouter) from the Command Palette (Ctrl+Shift+P) to:

• see the model you're currently using,
• change it by browsing OpenRouter's live catalog (free models are tagged) or entering a custom ID, and
• validate the choice — JSCR sends a tiny request with your key and confirms it works before saving.

The default cohere/north-mini-code:free works out of the box; any free-tier model is a good starting point.

Share a run

The panel header has a Save run as… button (next to Copy). It exports the current snippet and its output as either:

• Markdown — a code fence + output fence, ready to paste into a GitHub issue or PR comment.
• Standalone HTML — a self-contained, theme-coloured page you can drop into a doc or chat.

One click turns "let me screenshot this" into "here's the code, here's what it prints."

Scratch snippets

Snippets are file-backed and auto-saved with a 400 ms debounce — you'll never see a "save?" prompt. They live under:

• ~/.jscr/snippets/global/ — shared across all workspaces.
• ~/.jscr/snippets/projects/<workspace>/ — scoped to a workspace.

An JSCR Snippets view appears in the Explorer once you create one:

• 📁 Save to project (global rows only) — moves the snippet into the current workspace.
• 🗑️ Delete — with confirm.
• 🔀 Toggle language — renames .js ↔ .ts in place, ID preserved.
• Clear all — wipes global snippets (with confirm).

How it compares

Troubleshooting

See docs/LOCAL_BUILD_AND_USE.md § 11.

Contributing

Issues and PRs at github.com/wirekind/jscr.

Support

Questions, enquiries, or need a hand? Reach Wirekind Communications LLP:

• ✉️ Email — support@wirekind.com
• 🌐 Contact form — wirekind.com/contact
• 🐛 Bugs & feature requests — github.com/wirekind/jscr/issues

License

JSCR Freeware End-User License Agreement (EULA) — © 2026 Wirekind Communications LLP.

JSCR is free to download and use by both individuals and companies, including in commercial settings, at no cost. You may not modify, reverse-engineer, copy/redistribute, sublicense, rent, or sell the Software. All rights are reserved by Wirekind Communications LLP — see LICENSE for the full terms, or contact support@wirekind.com for permissions beyond this license.

Publisher

Wirekind Communications LLP — jscr.app