Watch your code actually run.

Flame turns any program into a step-by-step animation - every call, branch, and array swap, with the memory laid bare. Write it, watch NeonFlow trace it, and get graded in seconds. No install, no setup.

Get started Watch NeonFlow

Writing

{}solution.ts

Explorer

{}solution.ts

ttests.ts

{}package.json

##README.md

typescript

▍

2 tests waiting

How it works

From prompt to graded - with NeonFlow in the middle.

No CI configs, no test harnesses to teach, no spreadsheets. Just write code, watch it run, and get graded - all in the browser.

Step 01

Author the problem

Write the prompt, set starter code, attach hidden tests, define the rules.

Step 02

Spin up a batch

Create a classroom in one click and share the join link instantly.

Step 03

Watch it run in NeonFlow

Students don't just run code - they replay it, step by step, so a bug becomes something you can see.

Step 04

Auto-grade instantly

Submissions run against your hidden tests in seconds. Real execution, real output - no fake pass.

Step 05

Analyze & review

Per-student dashboards show who aced it, where they struggled, and let you replay their exact run.

Step →

See it yourself

The whole loop takes minutes. Open NeonFlow and watch your first program run.

Open NeonFlow

NeonFlow · the flagship

Not just whether it passed - see how it ran.

Two instruments, one running program. The source shows the line executing right now; memory shows the array cells actually trading places. They scrub together, step by step.

Sourcesort.ts

1function sort(arr: number[]) {

2 if (arr[0] > arr[1]) {

3 const temp = arr[0];

4 arr[0] = arr[1];

5 arr[1] = temp;

6 }

7 return arr;

10sort([8, 3]);

CALLsort([8, 3])

Memorylive

arr=[8, 3]

[

]

Flow

CALLBRANCHASSIGNMUTATERETURN

Run your own code

The cost of code

Two programs, a thousand times the work.

The fast version and the slow version of a program often look almost identical on the page. The difference only exists at runtime - drag the input size and watch it appear.

n = 64

At n = 64, an n log n algorithm does 384 steps. An n² algorithm does 4.1k - 11× the work for the exact same input. Hover the chart to compare all five at any point.

Why Flame

A platform that shows its work.

This section is a five-line program, and the page is executing it. Pause it. Drag it backwards. That's what Flame does to your code.

neonflow · tracing homepage-section.jsstep 1/24

▶const flame = new Platform();// boot the sandbox

02flame.run("two-sum.js");// hidden tests, real execution

03flame.replay(lastRun);// step through it like a film

04flame.watch(classroom);// teachers see it live

05return proof;

engine ready · sandbox on · 0 network access

hidden tests

two_sum([2,7,11], 9)…

two_sum([3,3], 6)…

empty input…

no valid pair…

✓ 4/4 passed · graded 100%

replay · your exact run

1let sum = 0;◀

2for (let i = 1; i <= 3; i++)

3 sum += i * i;

4return sum;

sum = 01/6

CS-204 · pass rate

live

Anika S.

Marcus C.

Priya P.

Diego R.

shown, not told

scrub me

Sandboxed runtime

Autosave everything

Keyboard-first editor

Shareable replay links

Tiered hints

Batch leaderboards

Labs

Write, run, test. No setup, ever.

A real editor, a real runtime, a real test runner - in the browser. Every problem ships with hidden grader tests so students learn by proving it.

{} solution.ts

typescript

grader statusAll Passed

returns doubled for small list
expect[6, 14, 4]
--
handles empty input
expect[]
--
preserves order
expect[2, 4, 6, 8]
--
rejects non-number values
expectTypeError
--
handles 10k entries under 50ms
expect<= 50ms
--

❯ flame test ./solution.ts

auto-run

28 languages out of the box

Python
TypeScript
Go
Rust
Java
C++
SQL
Ruby

Batches

Teachers run the class. Students run the code.

A batch is the thread between them: the teacher authors into it, every student joins with one code, and each submission runs in its own sandbox. Hidden tests stay hidden; the rubric does the grading.

Teacherauthors into the batch

Own the curriculum

Draft problems with starter code, edge-case tests and rubric weights. Clone last term's batch in one click.

Create a batchname it, share the join code
01
Post problemswith hidden tests + rubric
02
Auto-gradepass/fail in seconds
03

The batchFLAME-2026one code · everyone in

Studentjoins & runs the code

Prove it by running it

Write, test, submit. See exactly which tests passed and what your code actually did.

Join with the codeno signup friction
01
Solve in the browserreal editor, real runtime
02
Submit & see the flowgraded with feedback
03

Hidden tests stay hidden Rubric-weighted scoring Per-problem time limits

Engine breadth

One engine. Every shape of code.

NeonFlow doesn't ship a fixed set of canned demos. It executes the program you give it and animates whatever it finds - arrays, stacks, trees, graphs, recursion - in any of these languages.

Arrays. Sorts and searches, cell by cell - pointers slide as the window narrows.

JavaScriptPythonCC++JavaGoRust

One engine, exact traces. JavaScript and Python run natively; the rest trace through the same animated flow.

Animate your program

Roadmap

Built in the open. What's next.

We ship in public. Here's what's live, what's being built, and what's queued up next.

LiveQ1 2026

Shipping this quarter

Hidden-test graderRubric weights, time limits

Batches & rosterJoin codes, SSO ready

28-language editorVim, emacs, VSCode bindings

Phase 013 items

BuildingQ2 2026

In active development

Current focus

Submission replaysStep through any past run

Plagiarism clustersNear-duplicate detection

Teacher analyticsPer-problem failure modes

Phase 023 items

PlannedQ3 2026+

On the roadmap

Live class modeShared cursors, live grading

LMS bridgesCanvas, Moodle, Google Classroom

Premium runtimeAdvanced visualization layer

Phase 03

Pricing

Pay for runs. Own every language.

Every pack unlocks the full platform - all languages, exact-engine animation, real sandboxed execution. Packs differ only in how many NeonFlow runs you get, and runs never expire. Every new account gets 5 runs to try, no card needed.

Starter

Dip your toes in - a semester of casual practice.

$1.99≈ ₹191

+ 18% GST → you pay $2.35 (₹225 in India)

499 NeonFlow runs

0.40¢ per run

Get Starter

Pro

For serious learners grinding daily problems.

$5.99≈ ₹575

+ 18% GST → you pay $7.07 (₹679 in India)

2,499 NeonFlow runs

0.24¢ per run

Get Pro

Team

Study groups and small cohorts sharing a bench.

$11.99≈ ₹1,151

+ 18% GST → you pay $14.15 (₹1,358 in India)

4,999 NeonFlow runs

0.24¢ per run

Get Team

Campus

Classrooms and clubs - the best per-run price.

$23.99≈ ₹2,303

+ 18% GST → you pay $28.31 (₹2,718 in India)

12,499 NeonFlow runs

0.19¢ per run

Get Campus

Every pack includes

All languages: JavaScript, Python, C, C++, Java, Go, Rust
Exact-engine + AI flow animation for every run
Real sandboxed execution with true output
Memory view, Neon graph, data-structure animations
Runs never expire

Secure card payments worldwide via Dodo Payments. The "you pay" line is the final amount for India (18% GST added); other countries are taxed at their local rate at checkout. Have a coupon? There's a coupon box right next to the packs when you buy - in Settings or the NeonFlow playground.

Stop reading code. Start watching it move.

Spin up a Flame account in 30 seconds. Invite a class in another 60.

Create your workspace I'm a teacher

Featured on

Watch your code actually run.actually run.

From promptprompt to graded - with NeonFlow in the middle.