For people who make JSpark part of their day.

JSpark+

JSpark+ is the same app as JSpark, unlocked with a License Key. It adds more room and more tools, and it’s how JSpark keeps getting better.

Everything in free JSpark stays free. JSpark+ comes with the launch in October.

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⌄})

Run it to see the page

BrowserServer

loaded the notes from the server

added Pizza on Friday

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, and run together.
No port, no CORS: The page calls fetch("/api/…"), and its own server answers.
Two consoles: The page and the server each print to a console tab of their own.
On your Mac only: The server listens on your Mac alone. The page reaches it through JSpark.

Everything JSpark+ adds.

Anything not listed here is the same in JSpark and JSpark+.

A page with a server: Web Page + Server and React + Server Snippets, each side with its own console.
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.
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.
Longer, bigger Runs: Set a time limit of up to 10 seconds and 256 MB to 8 GB of memory, or press Run longer.
Every look: Every app theme and code colour, JetBrains Mono, and Fira Code with ligatures.
Editor extras: Tailwind class suggestions as you type, and Format Code before every Run.
Your Starters: Put the Starters in the order you like, and hide the ones you don’t use, so the list stays short.

Yearly or Lifetime.

Prices come with the launch in October.

Yearly

Pay each year. Every version released while you pay is JSpark+, even after you stop.

Lifetime

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

The same app: A License Key turns the JSpark you have into JSpark+, with nothing new to download.
Your work, kept: Upgrade or not, your Snippets, Library and settings stay as they are.
Two Macs, 30 days: One key works on 2 Macs. You can ask for a refund within 30 days of any payment.

Questions

Is there a free trial?

No. JSpark itself is free and doesn’t expire, so you can use it for as long as you like before you decide.

What’s the difference between Yearly and Lifetime?

Lifetime is one payment, and every future version is JSpark+. Yearly renews each year and covers every version released while you pay.

What happens if I stop paying for Yearly?

You keep the app. Every version released while you paid stays JSpark+, for good. Newer versions run as free JSpark, and nothing you made is touched.

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 at most once a day when you are online, and being offline never locks you out.

Do both editions get updates?

Yes. JSpark and JSpark+ both update themselves. Updates are not something JSpark+ adds.

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

Coming in October

Free, with no account. For Macs with Apple silicon.