JSCR runs your code the moment you stop typing — right inside VS Code, next to every line. No run button, no terminal switching, no context loss. JavaScript & TypeScript, plus ten more languages.
Every top-level expression is evaluated and reported next to its line — in real time, as you type.
Every expression is reported beside its line in real time. Stop typing for 300 ms — it runs. That's the whole workflow.
Run any .js/.ts file against your workspace's node_modules, or spin up persistent scratch snippets that survive restarts.
Hit a runtime error? Preview a two-column diff before you accept a single character. Works with the GitHub Copilot your team already has (VS Code 1.90+, no extra key) or a bring-your-own OpenRouter key — auto-detected, your choice.
Zero background processes when the panel is closed. JSCR only works while you're watching — nothing lingers, nothing polls.
Panel colors are pulled straight from your active VS Code theme — never hardcoded. It looks like it always belonged there.
First-class Python, Java, Go, Rust, C#, C++, Ruby, Groovy, Lua and Elixir alongside JS/TS — each auto-detected and running live.
Give a snippet companion files it can import — in all twelve languages. Ordinary import, require, mod, #include: JSCR uses each language's own resolution, no project needed.
Render instead of print: jscr.table(), jscr.chart(), jscr.image(), jscr.html(). A mini-notebook display — without the notebook.
One click runs the same snippet in a real terminal with live stdin — for menus, prompts and readline loops the live panel can't serve.
Render a webpage, not a console. React, Svelte, Vue, Preact, Solid, Lit, jQuery or plain HTML — live as you type, in its own pane.
Go, Rust and Lua compile or load to WebAssembly and render as a live page in the same pane — draw, print, fetch, re-rendering as you type.
No API key. No tokens. Nothing sent anywhere. Not gated by the Assist switch — these keep working, and stay in the menu, with AI turned off. Nothing here leaves your machine.
Run it N times, see the real distribution — min, median, p95, max, std dev and peak memory, with a bar per run. Warmup runs are discarded so a JVM's one-time JIT cost can't skew the median, and compiled languages compile once and re-spawn — so you measure run time, not ten compiles.
Ctrl+F in the panel. Highlight matches with a live counter, filter out everything that doesn't match, hide lines you don't want, or fold repeated lines into one ×N row. Copy and Save still export the complete run — filtering the screen never changes what you share.
Diff the last two runs, this run against an earlier one, or two snippets side by side. Or run both and diff what they actually printed — across languages. "Is my Rust port of this Python function equivalent?" answered by execution, not by a model's opinion.
Search matches name, language, folder, tags and file content — because "where did I write that binary search?" is the real question. Nestable folders you drag snippets onto, plus tags and favorites. Folders are virtual: your files never move on disk.
Every run quietly snapshots your code — deduplicated by hash, so unchanged re-runs cost nothing. Browse past versions, diff one against the current file, restore it. Restoring is itself undoable: the current content is saved first.
Snippets that hit real APIs need keys — and the snippet file is the last place one should live. Ordinary values go in a per-snippet .env; secrets go to your OS keychain and the file keeps only a placeholder. Nothing that copies a snippet can carry the credential, because the credential isn't in it.
Four tasks — the basics, read input, parse CSV, run work concurrently — each written in all twelve languages, standard library only. Every one of the 48 combinations is executed against its real toolchain before shipping, so a fresh template always runs.
Point JSCR at a folder your team already syncs — cloud drive, network share, or a git repo you manage yourself — and it becomes another root in the tree. JSCR doesn't run git for you; it delegates sync to whatever already does it. Secrets are never shared.
Benchmarks, diffs, search, snapshots, secrets — all computed from files on your disk and processes JSCR ran itself. No key to configure, no request budget to watch, nothing sent anywhere. Turn AI off entirely and every one of these still works.
Turn the scratchpad into a daily habit — a streak you don’t want to break, guided courses, and a challenge a day. Right where you already write code, no course site, no second tab.
A 🔥 N in your status bar that grows every day you practice or solve a challenge — and quietly resets if you skip one. The visible number that turns “tried it once” into “open it daily”.
Guided tracks — one per language, all twelve (Learn Rust Basics, Python for Interviews, Java Essentials, C++ Foundations…) — a few minutes a lesson. Built on the AI tutor: each lesson runs a preset practice session and advances you to the next when you finish.
An Advanced track for every language, open any time: six progressive stages — SOLID, the GoF Design Patterns (creational, structural, behavioral), Clean Code & Code Smells, and Refactoring. Every lesson is a runnable example plus an interview-oriented card: why it matters, real-world uses, common mistakes, interview questions and an exercise. Curated for Java, C#, TypeScript/JavaScript, Python & C++; AI-generated on demand for the rest.
Today’s problem, solved in any of twelve languages and graded by real execution against hidden test cases — no AI needed. December turns it into an Advent-of-Code-style run, and every solve gives you a shareable card.
Static editor-AI reads your source and guesses. JSCR's AI also sees the actual run — real per-line values, real errors, real output, real timing — so its answers are grounded in what your program did. Powered by the GitHub Copilot you already have (VS Code 1.90+, no extra key) or your own OpenRouter key; one master switch gates all of it.
Get it on the Marketplace
//? stating what it should do; JSCR flags it inline when the real output disagrees.JSCR Assist (default on) is the master circuit breaker — flip it off and every AI feature is disabled and hidden, and any on-screen card is dismissed. Uses your GitHub Copilot by default on VS Code 1.90+ (no extra key — great for teams on GitHub Enterprise/Business Copilot), or bring your own OpenRouter key (a free model works out of the box) — auto-detected, and switchable any time. Every feature works across all twelve languages.
Right-click any file → JSCR ▸ Practice with AI, and the Live Output panel becomes an interactive classroom. You learn where you already work — no course site, no second tab, no context switch. Type any topic you want (it's not a fixed curriculum) and drill it against a real runtime.
In Written Answer the AI writes a complete, runnable starter into the snippet — the problem as comments plus the language's boilerplate, cursor dropped exactly where you finish it. Submit, and it grades your code against its real execution output — not a guess about what it would print.
Written for hands-on building, Multiple Choice for fast recognition, Fill in the Blanks for recall, and Implement Template for building a real UI component. MCQ and Fill are graded instantly on-device against the answer key — no extra request, no waiting.
Four levels — Easier → Medium → Hard → Complex — so the same topic grows with you. Your level, mode and session length persist per snippet.
Every verdict comes with a 👍/👎 and an explanation of why. Advancing is manual — a wrong answer stays put so you can retry, or skip. A pinnable Info Pane offers a hint and the expected output when you're stuck.
Run 2–50 questions or an endless Stream ∞. Finish on a dashboard with your passed / failed / skipped tally and passing rate — then Restart or close.
All twelve languages — plus unknown file types, so you can drill any technology as plain text. Learn a new language, prep for interviews, or get fluent in a library against the deps you actually installed.
Pick React, Vue or Angular in the drawer and build a real component against a curated, AI-varied task. A left pane shows the problem plus a non-inspectable Target Preview (rendered to an image, so its DOM and data-testids can't be read); you write only the component, and Run Tests / Submit grade it with real Jest cases (~5–40, scaling with difficulty). Frameworks and Jest tooling download on demand into ~/.jscr — nothing bundled.
Persist any template challenge and pick it back up whenever you want. The whole challenge is saved to ~/.jscr/templates — the drawer config, the problem, the hidden Jest tests, the Target Preview and your in-progress code — then browsed under All Global Templates in the snippets tree, with a hover preview. Resume exactly where you left off; it leaves the store when you Submit or Delete it.
Questions render as formatted, syntax-highlighted code blocks in a modern drawer UI. Every session is isolated per snippet, so switching editors shows each one's own practice state. Gated by JSCR Assist like every AI feature — flip it off and it's gone.
Each toolchain is auto-detected on startup and cached, so launches stay instant. A language only appears when a supported version is found — everything else keeps working regardless.
Node 17+
3.8+
3.7+
JDK 11+
1.11+
1.39+
.NET 6+
14+
2.5.1+
2.5+
5.3+
1.9+
The small label under each language is its one-click package install — when a run hits a missing dependency, JSCR offers to fetch it into an isolated ~/.jscr store and re-runs. Every banner has an editable version selector (default latest, or pin any version — e.g. drop a broken latest back to a known-good release) and an Install Troubleshooter that diagnoses a failed install (deprecated / moved / renamed, version conflict, corrupt download, permissions) and, for Java/Groovy, offers a safe direct-download from Maven Central. Browse and remove what you've installed in the All Global Packages view — per language, with version, size and date, one-click delete. Every one of the twelve languages now has a package-install path.
C++ has no package manager of its own, so JSCR fetches the library itself — a curated catalog of header-only libraries (nlohmann/json, {fmt}, spdlog, Eigen, GLM, EnTT, Asio, doctest, Catch2, cpp-httplib, cereal, magic_enum, nameof, cxxopts, CLI11, argparse, toml++, range-v3, date, GSL, tl::expected, nanoflann, unordered_dense, ConcurrentQueue, tabulate and utfcpp) downloaded from each project's own release into ~/.jscr/cpp/include, which is already on every compile's -I. A missing #include is matched to its library and one click installs it; any flags it needs (-DFMT_HEADER_ONLY, the socket libs for cpp-httplib) are applied automatically, so the snippet declares nothing. Libraries that need compiled binaries and linker flags (OpenCV, Qt, Boost) are explained rather than half-installed — a single-file playground has nowhere to put them — and you can still drop any header-only library into that folder by hand.
Package install shells out to each language's own package manager, so that tool must be installed. Java uses Coursier to resolve a Maven group:artifact:version (with transitive deps) into ~/.jscr/java/lib — run with the JDK you already have (or a cs/coursier on PATH), so nothing extra to install. Lua needs luarocks — a separate download from the Lua interpreter; install it and add it to your PATH (or set jscr.luarocks.path) to enable Lua package install. Lua snippets still run without it. Pure-Lua rocks (e.g. dkjson, inspect, serpent) install in one click; C-extension rocks (e.g. lua-cjson, luasocket) additionally need Lua dev headers + a C compiler, so a binary-only Lua can't build them. luarocks targets Lua 5.1–5.4. Elixir uses hex via inline Mix.install.
Compiled languages (Go, Java, Rust, C#, C++) re-compile and run live on an idle debounce — never mid-keystroke. Turn it off per language to run on demand.
A scratchpad shouldn't cap out at one file. Give a snippet companion files and JSCR runs them together — using each language's own resolution, so you write ordinary code, not JSCR-flavoured code.
import · Ruby require_relative · Lua require · Go same-package · Rust mod · C# project globbing · C++ headers + extra units · Groovy classpath · Elixir -r.javac compile; JS/TS get an in-vm module loader — TypeScript companions transpile automatically.Text is a poor way to read a dataset. Call the ambient jscr API — no import, just like console — and the panel renders instead of prints.
jscr.table() — an array of objects, array of arrays, dict of columns, or a pandas DataFrame (duck-typed; pandas is never imported).jscr.chart() — bar, line, scatter, area, pie and donut, drawn as inline SVG that matches your VS Code theme. No charting library, no bloat.jscr.image() and jscr.html() — the latter in a sandboxed iframe, never the panel's own DOM.Some code isn't meant to print — it's meant to look like something. Open a React component, a Svelte file, a Vue SFC or plain HTML and JSCR renders the page, live as you type, in its own pane beside the editor.
.jsx/.tsx), Svelte, Vue (SFC or JS API), Preact, Solid, Lit, jQuery, plain DOM code and static HTML.Live Web isn't only for JS frameworks. Write Go, Rust or Lua, flip the WASM toggle, and JSCR compiles or loads it to WebAssembly and runs it right in the pane — drawing to a canvas, printing to a console, calling fetch — re-rendering as you type, in the same sandboxed webview React and Vue already use. No server, and no extra install for the toolchain you already have.
The js/wasm target is built into Go. JSCR builds your code with GOOS=js GOARCH=wasm and the wasm_exec.js that already ships in your GOROOT — nothing to add. Draw and print through syscall/js.
Builds for wasm32-unknown-unknown and runs wasm-bindgen — the cleanest DOM story of the three via web-sys. Missing the target or bindgen? JSCR explains the one-time setup in the pane, never an opaque failure.
JSCR ships a Lua 5.4 compiled to WASM runtime (wasmoon) and runs your script inside it — nothing to install at all, works offline. It injects document/canvas globals so a snippet can draw or print.
.go, .rs or .lua snippet and click the WASM button in the Live Output header — it flips that snippet from console to a rendered WASM page.fetch through JS glue — no raw sockets, threads or real filesystem. The right ceiling for a preview, and the same one every webview has.For code that reads stdin — Java Scanner, Python input(), Go fmt.Scan — type your input ahead of time in the Program Input box.
The panel's Save run as… button exports your snippet and its output in one click.
Beyond the twelve languages, JSCR turns a query file into a live database client. Write a query in the database's own syntax, press one shortcut, and the rows render as a rich table in JSCR — Live Output — with execution time and row counts, right where you already work. No new runtime: SQL rides the JVM JSCR already detects, and each NoSQL family runs over its native driver.
12 relational · one-click JDBC drivers
7 NoSQL · native drivers & REST
Amazon Aurora uses the PostgreSQL/MySQL driver. Drivers install one click from a picker into an isolated ~/.jscr/db_drivers store (Coursier, like a Java library) — except CouchDB/HBase, which need no driver at all (the JDK's built-in HTTP client).
A single dialog with real labeled fields per family — host, port, bucket, keyspace, region — not a raw URL to guess at. Connections are reusable global profiles with a Test Connection button; the password goes to your OS keychain (Windows Credential Manager / macOS Keychain), never to disk and never on the process command line.
SQL for relational. And each NoSQL family the way you already know it: MongoDB shell (use db, db.users.find(), show collections), Cassandra CQL, Couchbase N1QL, DynamoDB PartiQL or the AWS CLI (aws dynamodb scan …), Redis commands, CouchDB HTTP requests, and HBase shell (put / get / scan / create).
Press Ctrl+Shift+Enter (macOS ⌘+Shift+Enter) and results render in the JSCR — Live Output panel — a rich table (or JSON) with execution time and row counts, themed to your editor. Read-only queries also auto-run as you type on a short debounce.
Auto-run executes reads only — a SELECT, a Mongo find, a Redis GET — on a read-only connection, so a write can never fire from a keystroke. A write in the buffer shows a "this looks like a write — press Run" banner and executes only on an explicit Run, and a connection can be marked read-only to block writes even then (production databases).
A schema pane lists each family's own kinds — databases and tables, MongoDB collections, Cassandra keyspaces, Redis keys, DynamoDB tables — so you can explore a connection without leaving the panel.
Tunnel any host/port connection through an SSH bastion (custom port, private-key file or password — the SSH secret lives in the keychain too). Trust a private CA with a TLS certificate file for Couchbase / Cassandra / MongoDB. And per-family scale guards — a row cap with an honest "truncated" caption, streaming fetch, a query timeout and a per-cell cap — are always on so a huge result can't wedge the pane.
.sql statement, a .mongodb shell command, a .dynamodb AWS CLI line, a .redis command, and so on.Prefer a specific value? Everything is tunable via jscr.sql.* and jscr.<family>.* — debounce, row cap, fetch size, timeout, cell cap.
| Capability | JSCR | RunJS | Quokka |
|---|---|---|---|
| Runs inside VS Code | ✓ | separate app | ✓ |
| Live inline evaluation | ✓ | ✓ | paid tier |
| Persistent scratch snippets | ✓ | ✓ | ✕ |
| Uses workspace node_modules | ✓ | partial | ✓ |
| 10-language polyglot engine | ✓ | ✕ | ✕ |
| AI-assisted fixes (Copilot or BYO key) | ✓ | ✕ | ✕ |
| Free — including commercial | ✓ | ✕ | partial |
Open the Extensions view, search JSCR, hit install — then press Ctrl+Shift+J.
Buy me a coffee