For people who use JSpark every day.

JSpark+

JSpark+ is JSpark with more: a page with its own server, the Call Stack, installing npm packages, saving to the Library, and 11 more features.

1 device3 devices5 devices

Yearly

$12a year1 device

$19a year3 devices

$25a year5 devices

Pay each year. If the plan ends, you are back on JSpark, with all your work kept.

Get JSpark+ Yearly Get JSpark+ Yearly Get JSpark+ Yearly

Lifetime

$39once1 device

~~$59~~$49onceUntil 3 November

$79once5 devices

Pay once. Every version of JSpark, now and in the future, is JSpark+ for you.

Get JSpark+ Lifetime Get JSpark+ Lifetime Get JSpark+ Lifetime

30-day refund · Key by email · 1, 3 or 5 devices

The biggest thing JSpark+ adds.

A page, and its own server.

Write the page and the Node server it calls in one Snippet. Run it, and both start.

The page's code. It calls its server with a path on its own origin. Keep the

HTMLCSSTSServer

1⌄import http from "node:http"

2⌄

3⌄// The page's server: real Node, started by ⌘↵ beside the page.

4⌄// The app picks the port. The page reaches this server on its own origin,

5⌄// so fetch("/api/notes") needs no port and no CORS. Every path the app

6⌄// doesn't serve itself comes here, except /harness.js, /pkg/… and /r<n>/….

7⌄const notes = ["Buy milk", "Open the Server tab"]

8⌄

9⌄const server = http.createServer(async (request, response) => {

10⌄ console.log(request.method, request.url)

11⌄ const send = (status, body) => {

12⌄ response.writeHead(status, { "content-type": "application/json" })

13⌄ response.end(JSON.stringify(body))

14⌄ }

15⌄

16⌄ if (request.url === "/api/notes" && request.method === "GET") {

17⌄ return send(200, notes)

18⌄ }

19⌄ if (request.url === "/api/notes" && request.method === "POST") {

20⌄ let body = ""

21⌄ for await (const chunk of request) body += chunk

22⌄ let text

23⌄ try {

24⌄ ;({ text } = JSON.parse(body || "{}"))

25⌄ } catch {

26⌄ return send(400, { error: "Send valid JSON" })

27⌄ }

28⌄ if (!text) return send(400, { error: "A note needs some text" })

29⌄ notes.push(text)

30⌄ return send(201, notes)

31⌄ }

32⌄ send(404, { error: `Nothing at ${request.url}` })

33⌄})

34⌄

35⌄// The app gives this server its port. Pasted into a Node.js snippet, it

36⌄// falls back to 3000, as Node servers usually do. On this machine only: the

37⌄// page reaches it through the app, and nothing else on your network needs to.

38⌄const port = Number(process.env.PORT) || 3000

39⌄server.listen(port, "127.0.0.1", () => {

40⌄ console.log(`listening on ${port}; the page calls me on /api`)

41⌄})

PageConsole

Run it to see the page

Ready·Runs on demand

The Web Page + Server Starter. React + Server does the same with a React component.

One Snippet, two sides: The page and its Node server are Parts of one Snippet.
No port, no CORS: The page calls fetch("/api/…"), and its own server answers.
Two consoles: The page and the server each have a console tab.
On your computer only: The server listens on your computer alone, not the network.

The Timeline and Peeks are in JSpark. JSpark+ shows more of each.

See every call, and every pass of a loop.

The Timeline shows which functions led to each Step, and each callback as a Step of its own.

TimelineEditing is paused while you replay · Esc to go back

1⌄function factorial(n) {

2⌄ console.log("asking for", n)

3⌄ if (n === 1) return 1

4⌄ const rest = factorial(n - 1)

5⌄ console.log(n, "×", rest, "=", n * rest)

6⌄ return n * rest

7⌄}

8⌄

9⌄console.log("answer", factorial(4))

Console

asking for 4
L2
asking for 3
L2
asking for 2
L2
asking for 1
L2
2 × 1 = 2
L5
3 × 2 = 6
L5
4 × 6 = 24
L5
answer 24
L9

Variables

everywhere

factorial: Function

Call stack

global9

1 / 20

A recording of factorial(4). The Call Stack grows by one frame for each call, then unwinds.

TimelineEditing is paused while you replay · Esc to go back

1⌄const scores = [12, 7, 30, 4]

2⌄

3⌄const passed = scores.filter((score) => score >= 10)

4⌄const doubled = passed.map((score) => score * 2)

5⌄const total = doubled.reduce((sum, score) => sum + score, 0)

6⌄

7⌄console.log("total", total)

Console

total 84

Variables

Nothing in scope

Call stack

global1

1 / 18

Each filter, map and reduce callback is a Step, with its answer after the line.

The Call Stack: Which functions led to this Step. Click one to go to its line.
Inside lines: Each call, callback and loop check is a Step, with its result.
Every pass of a Peek: Hover a Peek in a loop to see its value on every pass.
Longer recordings: Up to 2,000,000 Steps a Run, where JSpark records 5,000.

For code you want to use, and code you want to keep.

Install a package. Keep a Snippet.

Add any npm package to your Snippets, and save the ones worth keeping to the Library.

empty

1⌄import { addDays, format } from "date-fns"

2⌄

3⌄const due = addDays(new Date(2026, 8, 28), 30)

4⌄

5⌄console.log(format(due, "EEEE, d MMMM"))

6⌄console.log(format(due, "yyyy-MM-dd"))

Wednesday, 28 October

2026-10-28

Ready·Runs as you type

Search npm…

react

react-dom

svelte

three

vue

react

Installed 19.3.0Node Web

19.3.0(latest)

React is a JavaScript library for building user interfaces.

174.5 kBnpmPublished2 weeks ago203,498,378/week

Required by the React Starter (^19). Stays while it’s here.

react

React is a JavaScript library for creating user interfaces.

The react package contains only the functionality necessary to define React components. It is typically used together with a React renderer like react-dom for the web, or react-native for the native environments.

date-fns, from search to import. The facts and the output are npm’s and Node’s own.

Packages from npm: Install, update and remove packages from the Packages window.
Searching is in JSpark: JSpark can search npm and read READMEs. JSpark+ installs.
Keep a Snippet: Save it with a title, a note and Tags, and edit it later.
Import a Library: Bring in a Library from another computer. JSpark can export one.

In JSpark, the time limit is 5 seconds and the memory limit 1 GB.

When a Run needs more time or memory.

Run it once more with a higher limit, or raise the limit for every Run in Settings.

let longest = 0

1⌄let longest = 0

2⌄let start = 0

3⌄

4⌄for (let n = 1; n < 5_000_000; n++) {

5⌄ let x = n

6⌄ let steps = 0

7⌄ while (x !== 1) {

8⌄ x = x % 2 ? 3 * x + 1 : x / 2

9⌄ steps++

10⌄ }

11⌄ if (steps > longest) {

12⌄ longest = steps

13⌄ start = n

14⌄ }

15⌄}

16⌄

17⌄console.log(start, "takes", longest, "steps")

Stopped: busy for 5.037s without a pause

It never paused for that long, which usually means an endless loop. Here’s what it got through.

Run longer

Stopped: busy for 5.0s·Runs as you type

const rows = []

1⌄const rows = []

2⌄for (let i = 0; i < 12_000_000; i++) {

3⌄ rows.push({ id: i, name: `row ${i}`, done: i % 3 === 0 })

4⌄}

5⌄

6⌄const done = rows.filter((row) => row.done).length

7⌄console.log(rows.length, "rows,", done, "done")

Stopped: used more than 1 GB

Here’s what it got through.

Run with more memory

Stopped: used more than 1 GB·Runs as you type

Run longer: After the time limit, run it once more for up to 10 seconds.
Run with more memory: After the memory limit, run it once more with twice the memory.
Your own limits: In Settings: up to 10 seconds, and 256 MB to 8 GB of memory.
The same guard: The loop guard works as in JSpark. Only the limits move.

You look at it all day.

Pick your colours and font.

Click a look to see the window in it.

A small demo, so there is something to run. Clear it and write your own.

1⌄// A small demo, so there is something to run. Clear it and write your own.

2⌄// A `//?` after a line shows what it came to; hover the value for every pass.

3⌄const scores = [12, 7, 30, 4]

4⌄

5⌄let total = 0

6⌄for (const score of scores) {

7⌄ total += score //? → 53

8⌄}

9⌄

10⌄console.log("total", total)

11⌄console.log("highest", Math.max(...scores))

12⌄

total 53

L10

highest 30

L11

Done in 4ms·Runs as you type

Every app theme: Six app themes, where JSpark has Night and Day.
Every code colour: Twelve Code Themes, where JSpark has Plain and Moss.
Your font: Fira Code ligatures and JetBrains Mono.
Editor extras: Tailwind class suggestions, and Format Code before each Run.

Everything in JSpark+.

Every feature of free JSpark, and these as well. Anything not listed here works the same in both.

Longer recordings: The Timeline records up to 2,000,000 Steps, where JSpark records 5,000.
Inside lines: Step into each call, callback and loop check, and see what each one came to.
The Call Stack: At every Step of the Timeline, see which functions called the one you are in, and in what order.
Every pass of a Peek: Hover a Peek inside a loop to see the value it had on every pass, not only the last one.
A page with a server: Web Page + Server and React + Server Snippets, each side with its own console.
Open in Browser: Open a Web Snippet’s page in your own browser, with its DevTools. It reloads as you edit.
Longer, bigger Runs: Set a time limit of up to 10 seconds and 256 MB to 8 GB of memory, or press Run longer.
Run in your folder: Run a Snippet in a folder of your own, so it can import your files and use your packages.
More variables: Keep as many environment variables as you need, and load the Working Folder’s .env.
Install packages: Install, update and remove npm packages. JSpark can search them and read them.
Save to the Library: Save Snippets to the Library, edit them, and import a Library from a file.
Unlimited tabs: Keep as many Snippets open as you like. JSpark keeps up to 3 open at once.
Your Starters: Put the Starters in the order you like, and hide the ones you don’t use, so the list stays short.
Every look: Every app theme and code colour, JetBrains Mono, and Fira Code with ligatures.
Editor extras: Tailwind class suggestions, Format Code before every Run, and your own format style or .prettierrc.

View all features

Priced per person: one License Key, for you, on 1, 3 or 5 devices. Polar handles the payment, the tax and your key.

The same app: A License Key turns your JSpark into JSpark+, in place.
Your work, kept: Upgrade or not, your Snippets, Library and settings stay.
Your devices, 30 days: One key is for you, on 1, 3 or 5 devices, as you choose. Any payment is refundable for 30 days.

Questions

How much does JSpark+ cost?

It depends on how many computers your License Key is for. Yearly is $12, $19 or $25 a year, and Lifetime $39, $59 or $79, for 1, 3 or 5 computers. Polar handles the payment, the tax and your key. Launch offer, until 3 November: Lifetime for 3 devices is $49 instead of $59.

Do I need an account?

No. The checkout asks for your email address, so it can send you your License Key. There is nothing to sign in to.

Does JSpark+ work offline?

Yes. Turning a key on needs a connection once. After that, JSpark+ checks the key when the app starts and once a day while it stays open, when you are online, and being offline never locks you out.

What happens if I stop paying for Yearly?

JSpark+ lasts until the end of the year you paid for. Then the app goes back to JSpark, the free edition, and you keep everything you made: saved Snippets stay openable, installed packages keep working and your settings stay. Renew at any time and JSpark+ comes straight back.

Can I switch from Yearly to Lifetime?

Yes. Buy Lifetime, cancel the Yearly plan on Polar’s customer page, then in Settings → License click Replace key… and paste the new key. Lifetime is full price, with no credit for what you paid on Yearly.

Do I still get updates on JSpark?

Yes. Every new version, with its fixes, reaches everyone, whichever edition they have. The app updates itself in both.

How many computers can I use it on?

As many as your License Key is for: 1, 3 or 5, chosen when you buy, Mac or Windows in any mix. A key is for one person. To move to another computer, click Deactivate this device… in Settings → License on the old one first. To add computers to a Yearly plan, switch it on Polar’s customer page: you pay the difference and get a new key. A Lifetime key can’t be switched: within 30 days, ask for a refund and buy the larger one.

Can my team or company buy JSpark+?

Yes, one License Key per person. Each person can buy their own, or one buyer can buy several, one at a time. Each key can be for 1, 3 or 5 computers. There is no team plan and no shared key.

Can I get a refund?

Yes, within 30 days of any payment, renewals included, with no questions asked. Your key stops working and the app goes back to JSpark. Nothing you made is deleted.

Is there a free trial?

No. JSpark itself is free and doesn’t expire, so it is the way to try the app for as long as you like. The 30 days are for refunds, not a trial.

The price is too much for me. Can I get a discount?

Maybe. Email support@jspark.app and say why the price doesn’t work for you: for example, you are a student, or prices where you live are much lower. Every email is read, and when the reason is clear, a discount is given.

Start with JSpark. JSpark+ is there when you want more.

Download free for Mac

Not a trial: it doesn’t expire.

Windows

Download free for Windows

Not a trial: it doesn’t expire.

Mac

Download free

Download free for Mac Download free for Windows

Not a trial: it doesn’t expire.

JSpark+· From $12 a year, or $39 once. 30-day refund.

Get JSpark+