Product · Changelog
What's new
Every release that shaped LiveFlow — new capabilities, sharper edges, and the fixes in between. Newest first.
Scrub with confidence — and type without surprises
A timeline-accuracy and language-correctness release. As you scrub, every array, object, and variable in the graph now shows its value at that exact step instead of its final value. Plus a deep pass across all three languages ahead of launch: TypeScript decorators work, async/await and generators trace cleanly, classes and special values render correctly, and the editor no longer drops the spacebar.
- NewTypeScript decorators are now supported — files using @Component / @Injectable / @Entity-style decorators trace normally instead of failing to run.
- NewLambdas (Python) and arrow functions (JavaScript/TypeScript) now show their execution in the graph — including concise one-liners like map(lambda x: ..., xs) / arr.map(n => ...) and multi-line bodies — instead of being skipped.
- NewAPI and dependency calls now show how long they took: a small timer on the dependency node reports the call's wall-clock time. await-ed/async calls (e.g. await axios.get(url)) are measured until they actually finish, so you see the real request time, not zero.
- FixedPython async/await and generators now trace as a single, clean call instead of being flagged as errors (the normal end-of-iteration was being mistaken for a thrown exception). JavaScript class instances now show their actual (most-derived) class name, and class getters are no longer run while we inspect an object — so a getter's side effects can't fire during tracing.
- FixedSpecial values render correctly everywhere now: NaN and Infinity (which previously could drop a whole step from a Python run), and very large integers (kept exact instead of rounded). JavaScript/TypeScript exceptions also show their propagation path up the call stack, matching Python.
- ImprovedLaunch hardening: a program that prints a giant value or leaves a background process running can no longer stall or balloon a run, error messages no longer leak internal file paths, and saved traces from multithreaded programs stay intact.
- FixedTimeline scrubbing now shows point-in-time values. Arrays, objects, sets, instance fields, variables, console output, and the dependency panel render their state at the selected step — not the final value — so stepping back through a run shows the program exactly as it was. Previously a collection appeared already full before its elements were added, and the console showed the whole run's output at every step. Single-file and project modes; Python, JavaScript, and TypeScript.
- FixedThe Variables panel is more accurate: top-level JavaScript/TypeScript variables now appear under Globals (they were hidden before), and a function's locals no longer linger in the panel or as inline hints after that function has returned at the current step.
- FixedIn project mode, the editor no longer scroll-jumps to a line number in a different file as execution crosses files while scrubbing.
- FixedConsole output now lines up with the line that produced it for Python runs (it could appear one step early), and jumping to an earlier step during a live run no longer snaps you back to the end as new events arrive.
- FixedThe code editor no longer drops the spacebar (and occasional other keystrokes) while typing. This was caused by the editor's experimental input path on recent browsers; we've moved back to the proven one.
- FixedLoop nodes now show the real iteration count for JavaScript and TypeScript runs instead of always reading "iteration 1".
- FixedReassigning a variable to a different shape — say a list to an object — now updates the graph to the new shape instead of rendering the new value in the old layout.
- ImprovedNested collections, function arguments, and return values now display as readable values in the graph (e.g. [1, 2, 3] and {a: 1}) instead of raw internal data. Also fixes captured console output for buffered writes, function arguments declared with destructuring or rest (…args), and objects referenced more than once in the same structure. JavaScript and TypeScript.
See every value, and jump straight to what broke
Debugging got faster: every variable's current value now reads right next to its line as you scrub, you can click a value to jump to the step that set it, and a run that errors lands you on the failing line with the cause in view. Search by value, and share a link that opens at the exact step. All of it works in Python, JavaScript, and TypeScript.
- NewInline values — each in-scope variable's current value now shows as faint text at the end of its source line, in sync with the timeline. Read your program's state straight from the code instead of hunting through panels. Python, JavaScript, and TypeScript (lists, maps, and objects render readably, not as raw data).
- New"Who set this value?" — click any variable in the inspector to jump the timeline to the exact step that produced its current value, so you can trace a wrong result back to its cause in one click.
- NewLand on the error — when a run throws, the timeline now jumps straight to the line that failed, with the values that caused it already in view. A "Jump to where it broke" button brings you back there anytime you've scrubbed away.
- NewSearch by value — type something like x=7 in the step search to jump to the moment a variable became that value, alongside searching by line number, function, or variable name.
- ImprovedShare a precise moment — replay links can now open at the exact step you were on, and shared replays support the same inline values and value-jumps.
New ways to see your code — call trees, data structures & more
The execution graph gained a row of focused views: see recursion as a call tree, linked lists and trees laid out as structures, dynamic-programming tables as heatmaps, and a whole project as a cross-file sequence diagram or module map. Two-pointer cursors now show right on the array, a new Feature guide tours everything LiveFlow can do, and we closed an account-switching bug.
- NewFocused graph views — a tab bar on the execution graph switches between purpose-built lenses on the same run: a Call Tree for recursion (with markers on repeated sub-problems), a Structure view for linked lists and trees, a Grid heatmap for dynamic-programming tables, plus cross-file Sequence and Architecture maps for whole projects. Each tab appears only when your run has something to show, so nothing clutters.
- NewTwo-pointer cursors — named index variables like lo / hi / left / right appear as labeled markers right above the array cell they point to, so sliding-window, two-pointer, and binary-search algorithms read at a glance. Works in Python, JavaScript, and TypeScript.
- NewLoops, branches, and console output are now first-class nodes on the graph — watch a loop's iteration count climb, see which branch was taken, and follow program output as it streams.
- NewA Feature guide — one page that tours everything LiveFlow can do, linked from the home page and your account menu.
- NewRuntime timeouts are now visible — when a run exceeds the time limit you set, it's stopped on the backend and marked with a clear timeout node on the graph. The timeline stays scrubbable right up to the moment it was stopped, so you can replay exactly how far it got.
- ImprovedThe execution graph now keeps the active node centered — as a run streams and as you scrub through playback, the graph pans to follow whatever is currently executing instead of letting it drift off-screen.
- ImprovedNewly-added list and array items stay in view — append to a collection and the node scrolls to reveal the new value instead of leaving it off-screen, even for very large collections.
- FixedSwitching accounts is now fully isolated — signing out and into a different account no longer restores the previous account's open workspace, favorites, or recorded runs on a shared browser.
Your new dashboard — projects, history & usage in one place
A personal dashboard brings your saved projects, recent runs, and remaining daily quota into one view. We also made signing in for live runs more secure and applied per-account limits consistently, so LiveFlow stays fast and fair for everyone.
- NewA personal dashboard — jump back into your saved projects, see your recent runs and favorites, and track how much of your daily quota is left, all from the account menu.
- NewSaved multi-file projects and run history, with at-a-glance usage meters for your daily runs and saves.
- ImprovedTry before you buy — every paid plan starts with a 7-day free trial of that plan, cancel anytime.
- ImprovedMore secure live runs — the editor now connects with a short-lived, single-use ticket instead of carrying your sign-in token in the address bar.
- ImprovedFairer, more reliable limits — per-account run and save caps are applied consistently, so one account can't crowd out everyone else.
Your favorite libraries, built in
Import the libraries you actually reach for — NumPy, pandas, lodash, day.js and more — ready to use, with nothing to install. A new Libraries page shows what comes with each plan and lets you request more, the editor now follows your code across files as it runs, and we’ve freshened up the wording, footer, and error messages across the site.
- NewBuilt-in libraries — import NumPy and pandas in Python, or lodash, day.js, zod and math.js in JavaScript/TypeScript, right away. No installing, no setup.
- NewA new Libraries page — see exactly which libraries come with your plan, and request one you’re missing. Find it in the footer or your account menu.
- ImprovedEvery plan shows its libraries — Free comes with handy JavaScript helpers; Basic and Pro add the bigger number-crunching libraries like NumPy and pandas.
- ImprovedThe highlight follows your code across files — when one file calls another, the editor jumps to that file and back, so you can trace the whole path live or on replay.
- ImprovedClearer, friendlier wording across the site, plus a redesigned footer.
- FixedFriendlier error messages — if something goes wrong on our end, you’ll see a clear, plain message instead of a wall of technical text.
- FixedJavaScript and TypeScript runs that could sometimes fail to start now run reliably.
Export your traces — and a fresh new look
Turn any run into a structured trace you can export and search — download it as JSON or JSONL for your tools and AI agents, save it to your account, and jump straight to any line, function, or variable, in a tidier, touch-friendly workspace. Plus a redesigned home page built around the real tool, a bolder new typeface, subtle motion across the public pages, and a file panel you can collapse for full-width code.
- NewExport a trace as JSON or JSONL (“Trace export v1”) — a stable, structured record of calls, state changes, collections, and control flow that your tools and AI agents can read.
- NewSave a run as a trace — it’s recorded on the server, so what you save is exactly what ran.
- NewStep search — type a line number, function, or variable in the navbar and the timeline jumps to every matching moment; Enter cycles through matches.
- NewGuided tour for project mode, plus new stops for search and share/export in single-file mode.
- ImprovedTidier toolbars — Share, Save, and Export now sit under one Actions menu, project file actions under a Files menu, and the editor toolbar fits on a single line.
- ImprovedTouch-friendly playback — show or hide the timeline controls with a caret tap instead of hover.
- ImprovedSign-up now reminds you to check your spam folder if the verification code isn’t in your inbox.
- ImprovedThe Student plan — free first month, then ₹10/mo for allowlisted college emails — is now live.
- ImprovedRedesigned home page — a clearer story for the three ways people use LiveFlow (learning DSA, understanding a codebase, and running AI-written code), with a live demo built from the real execution-graph nodes.
- NewCollapse the file panel — hide the project file sidebar with one click to give the editor the full width.
- ImprovedA fresh typeface throughout — a bolder display font with an elegant italic serif accent for a more editorial feel.
- ImprovedSubtle motion across the public pages — content fades in as you scroll, with a gentle glow behind the hero.
Saved multi-file Projects
LiveFlow runs real projects now — drop in a folder of Python, JavaScript, or TypeScript files, watch imports trace across them, and save named projects that expire on their own.
- NewMulti-file Projects (Basic & Pro) — run a whole project, not just one file, and watch calls and imports trace across files in the same live graph and timeline.
- NewA dedicated Projects workspace — switch between Single file and Projects from the navbar, browse your files in a folder tree, and choose which file runs.
- NewFolder & .zip upload — drag in a folder or a zip and LiveFlow keeps just the source files; no copy-paste, no git.
- NewCross-file tracing for Python, JavaScript & TypeScript — when your code spans several files, LiveFlow follows it across all of them.
- NewSave projects with per-plan quotas — Basic keeps 2 projects (10 files, 2-week retention), Pro keeps 5 (25 files, 1-month retention); each auto-expires from the day you save it.
- ImprovedServer-side ingest hygiene — node_modules, build output, and binaries are rejected on the server before anything runs, so a project stays just your source.
- ImprovedClearer rejections — file-limit, size, and upload errors now surface as toasts instead of silent failures.
In-app checkout & a calmer workspace
Upgrading now happens without ever leaving LiveFlow, and the workspace lost its banner clutter so the editor and graph get the whole screen.
- NewIn-app Razorpay Checkout — pay in a modal and get an instant “you’re on Pro” confirmation, no redirect, no dead-ends.
- ImprovedPlan and trial notices are now dismissable toasts instead of banner rows, freeing the full height for your code and the runtime graph.
- ImprovedOne unified toast system across the app — registration, billing, cancellations, and errors all speak with the same voice.
- FixedThe Student pricing card’s button now lines up with the other plans.
JavaScript, TypeScript & a free tier
LiveFlow stopped being Python-only. JavaScript and TypeScript now run in the very same live graph and timeline, and a free tier opened the door for everyone.
- NewJavaScript & TypeScript execution — watch JS/TS run in the same scrubbable timeline and runtime graph as Python.
- NewFree tier — 5 JavaScript runs a day with the full visualizer, no card required.
- NewStudent tier — a free first month then ₹10/mo for students on an allowlisted college email.
- NewShareable replay links — send a public, read-only replay of any run; it rehydrates the exact timeline with no re-execution.
LiveFlow goes live
The first public release: accounts, the runtime visualizer, and the scrubbable timeline that makes execution something you can watch and rewind.
- NewPublic launch — email + OTP accounts, the live execution graph, and a timeline you can scrub to any step.
- NewSubscriptions via Razorpay — Basic ₹199 and Pro ₹499, each starting with a 7-day free trial.
- ImprovedA safe space for every run — your code runs sealed off on its own, with no internet and limits on time, memory, and CPU, so it can never reach your computer.
- ImprovedSEO foundation — sitemap, robots, Open Graph cards, and structured data shipped from day one.