A personal code editor for Python, C and C++ that runs programs in the browser. Files live in
folders in a workspace kept in the browser's storage (IndexedDB), and can be kept in a private
GitHub repository. Compiling and running happen on your own computer, in WebAssembly workers. The
only server-side piece is a small sign-in relay on the same site for "Sign in with GitHub"
(functions/api/auth/, see Keeping the files on GitHub); it stores
and logs nothing, and syncing never goes through it.
- Python 3.14 through Pyodide 314.0.7, with numpy and pandas (downloaded the first time a program imports them).
- C and C++ through clang and lld 22 compiled to WebAssembly
(YoWASP's
@yowasp/clang) with wasi-sdk 33's C and C++ libraries, so C++ exceptions (try,throw,catch) work. Programs can have several files and headers in one folder, and can read and write files in that folder. - Programs read typed input while they run (
input(),scanf,std::cin), and Stop works at any point. Compiler and Python errors are marked on the line they belong to, in every file of the program, and listed under Problems. - Error help in plain English for the errors beginners meet most (65 message shapes, such as
a
NameErrorwith a suggested name,str + int, a missing colon or bracket, an undeclared identifier, a missing#includeor;, a printf or scanf format mismatch, a crash): what the message means, with the names from it filled in, and one or two things to check. It shows under the failed run's error in Output and under the first Problems row of each kind. It comes from a table in the app, checked against messages the real Python and compiler printed; nothing is sent anywhere, and no AI writes it. - Command-line arguments: the Input box (the Output panel's Input button) has an Arguments field
beside the Input text, kept for each file (it follows a rename and goes with a delete). Words
split at spaces;
"two words"or'two words'in quotes stay one argument and""is an empty one. Nothing else is special: no backslash escapes, and$HOME,*,;,|and>are passed as text, since no shell runs. In Pythonsys.argv[1:]holds them (sys.argv[0]is the script's path,/workspace/main.py); in C and C++argv[0]is the file's name without its extension (mainfor main.c) and the arguments follow. At most 100 arguments and 4,096 characters; an unclosed quote is shown at the field, and Run explains it instead of running. - Works offline once it has been set up: a service worker keeps the app. It starts when Python has loaded, or a minute into the first visit, or when the C/C++ pack downloads. Python itself (about 13.5 MB) downloads the first time a Python file is opened or run, not on every first visit, and is then kept for offline use, like the C/C++ pack. Opened offline before that, Python says it needs one online start.
- Suggestions as you type: keywords and snippets, the standard library's names, and your own names (see Suggestions).
- Capture snippet: right-click selected code (or press Shift+F10) to make an image of those lines, with a preview: copy it or download a PNG. Shift+right-click gives the browser's own menu. The same command is in More file actions and, on wider screens, at the end of the editor head. The preview shows exactly what is exported. Options: colours (the editor's, light or dark), line numbers, the file name, a background in the theme's colours with small, medium or large padding (or none: the code card alone, with transparent corners), a plain or window frame (a title bar with the file name), the scale (1x, 2x or 3x; the exact pixel size is shown, and a scale too big for one image steps down and says so), and lines to highlight ("3-5, 8": a band behind those lines; nothing else is dimmed), and a small "Made with ExecFlow" line under the card (on by default; turn it off under Show). The options are remembered on this device; the highlighted lines are not. Nothing is sent anywhere: the image is made in the browser and works offline.
- Save as PDF... (in More file actions and the search): choose one or more files, then the browser's print dialog opens; choose "Save as PDF" as the printer there. The code keeps the editor's syntax colours, in print-safe dark ink on white by default (or the editor's own colours), with line numbers (optional); long lines wrap with a continuation mark, and each file starts on a new page under its path. A footer (on by default) gives the file, the date and "Made with ExecFlow" on every page, and in Chrome and Edge the page number ("Page 2 of 5"). Firefox and Safari can't number pages for a web page: there the footer has no page number and is printed with each file's code (their print dialog can add its own page numbers). Works offline; the PDF is made by the browser, so its text can be selected and searched.
- Share link... (a file's menu in the list, More file actions, and the search): a code link that carries the file inside the link (no account needed), or, with GitHub connected, a link to the file in your repository or a secret gist. See Sharing a file.
- Download (a file's or folder's menu in the list, and the search): a file as itself, byte for byte as saved; a folder as a .zip that unpacks to that folder.
- Choose files to download or share... (More file actions, and the search): tick files and whole folders, then download them (one .zip, named after what is ticked) or share them in one code link of up to 8,000 characters, roughly 15 to 20 KB of code. Opening a shared folder shows each file first; Add puts it in a new folder at the top (lab1, or lab1-2 when that name is taken).
- Files a program writes: data files are saved to your files at once; new code (.py, .c, .cpp or a header) waits for Keep it, since later runs would build it; dismissing the question, or the next run, leaves it out. A program never writes over existing code, and only files in its own folder are saved; a program from another folder starts with a fresh Python.
- Search files and commands: Ctrl+P (Cmd+P on macOS) or Search in the top bar finds a file by its name, and any command; F1 or Ctrl+Shift+P lists the commands only (Firefox keeps Ctrl+Shift+P for a private window: use F1 there). Each command shows its keys. See Keyboard.
- Flowchart (a tab beside Output and Problems; a fourth view on phones): the open C, C++ or Python
file drawn as a flowchart, one chart per function (the entry point first:
main, or a Python file's top level, "Program"), with the shapes of lab records: Start and End, steps, decisions with Yes and No (a switch's cases by value), input and output, calls to the file's own functions, and connectors forgoto. Up to three simple statements share a box; try/catch, with, lambdas and macros are one box each, "shown as one step". Click a box to select its lines in the code; move the caret and its box is outlined; Tab reaches the boxes as one list (arrows, Home, End; Enter goes to the code), and "Steps as text" gives the same chart as a numbered outline. Zoom, fit, drag to pan, Ctrl+wheel or pinch to zoom; Full screen shows it over the whole window (Esc leaves). It redraws 300 ms after typing stops. A line with a mistake is named, with a link to it, and the chart shows what parses. Limits: 400 boxes and 40 levels of nesting per function, 1 MB per file. Its parser (tree-sitter) downloads the first time a chart is shown for a language (about 1 MB for C or Python, 3.7 MB for C++, before compression), and then works offline. - New from example... (in More file actions, the search, and the empty workspace): nine short programs, three each for Python, C and C++, added to your files under a free name and opened.
- New file (the file list): the name field suggests
name.py, name.c or name.cpp. A name that won't run is said before the file is made; one with no extension at all needs Enter twice. A new Python, C or C++ file starts from the same short program as the empty workspace's starters, unless its folder already has a file of that language (then it is a helper and starts empty).
Needs Node 24.18 (see .node-version) and npm 11.
npm ci --ignore-scripts
npm run devnpm run dev first copies Pyodide out of node_modules and downloads, with a SHA-256 check for
every file, the numpy and pandas wheels (about 7.5 MB, from Pyodide's CDN) and the C/C++ pack
(about 29 MB once packed, from npm's @yowasp/clang and wasi-sdk's GitHub release, both pinned by
hash), and the flowchart's three grammars
(about 4.3 MB of .wasm, from jsDelivr) into public/. Later runs use a
cache in node_modules/.cache/. Then it serves the app on http://localhost:5173.
Other commands:
| Command | What it does |
|---|---|
npm test |
Unit tests (Vitest): the app (src/), then the sign-in relay (server/) |
npm run typecheck |
TypeScript for the app, the workers, the tooling and the sign-in relay (functions/, server/) |
npm run dev:pages |
After npm run build: the built site plus the sign-in relay on http://127.0.0.1:8788 (Wrangler; needs a .dev.vars, see below) |
npm run build |
Type check, then a production build in dist/ with a Cloudflare Pages _headers file |
npx playwright install chromium firefox webkit |
Once, before the end-to-end tests |
npm run e2e |
End-to-end tests against the production build, in Chromium, Firefox and WebKit; the typing-speed test runs last, alone |
npm run e2e:speed |
Only the typing-speed test (e2e/speed.spec.ts, --project=speed --no-deps), which npm run e2e skips when an earlier test failed. Naming the spec file or the speed project without --no-deps runs every engine's tests first |
node scripts/contrast-check.mjs |
WCAG contrast of every colour pair the UI draws, for every theme |
GitHub Actions (.github/workflows/ci.yml) checks every push to main and every pull request.
One job runs npm ci --ignore-scripts, the type check, the unit tests and npm run build; when
it passes, the end-to-end suite runs in Chromium, Firefox and WebKit: one job each for Chromium
and Firefox, and WebKit as three shards (--shard=1/3 to 3/3) to stay under the 60-minute job
limit (the Chromium job also runs the typing-speed test, with one worker as every CI job). The
downloads in node_modules/.cache/ are kept between runs, and a failed end-to-end job keeps its
test-results/ folder as an artifact for 7 days. CI doesn't hold back deploys: Cloudflare Pages
builds every push to main on its own.
A list of suggestions opens as you type. It offers keywords and snippets (for, if, main,
printf, class...), the standard library's names, and your own names:
- Python: module names after
importandfrom, and a module's members aftermath.orfrom math import. Your own modules (helpers.pybeside the file) and their top-level functions, classes and variables are offered too. - C and C++: header names after
#include <(and your headers after#include "), library functions and constants with their prototype or value, andstd::names in C++. After your ownusing namespace std;the std names come without the prefix too (vector,cout), below your own names, wherever C++ lets you use them: after the line, and only inside the block or namespace it is in. They follow the C and C++ standard chosen in Settings, and a function that doesn't link here (gets,system) is never offered. Your own functions, types, globals and macros come from the open file and the headers it includes with quotes.
The library lists are generated from the C/C++ pack's sysroot and from Pyodide
(scripts/gen-c-completions.mjs, scripts/gen-python-completions.mjs), load the first time a file
of that language is shown, and work offline after the first visit. Keywords and snippets come with
the editor itself, so they are offered even if the rest can't load yet.
- The top suggestion is picked when the list opens, so Enter accepts it; Down or Up picks another.
If the top suggestion is just the word you typed (
printtyped in full), Enter makes a new line unless an arrow key picked it. Otherwise Enter accepts what is on top:n = ibecomesn = idwhen the file has noi, and a snippet such asdef,iformainstill expands (afterint,mainwrites the rest of the function). Tab never accepts one. With "Enter accepts the top suggestion" off in Settings, nothing is picked until Down or Up, and Enter makes a new line. - Ctrl+Space shows the list at any time (on macOS also Alt+`). "Suggestions while typing" in Settings stops the list from opening by itself.
- Esc closes the list, or ends a snippet. Inside a snippet, Tab and Shift+Tab move between its fields, except while Tab moves focus (Ctrl+M, or Shift+Alt+M on macOS): then Tab leaves the editor.
The Shortcuts list has every key: Shortcuts in the status bar, or Ctrl+/ (Cmd+/ on macOS) anywhere outside the code and text fields (inside the code, Ctrl+/ comments the line). The ones to know first, with Cmd for Ctrl on macOS:
- Ctrl+Enter runs the open file, Ctrl+. stops it, Ctrl+S saves now (and syncs once connected).
- Ctrl+P searches the files and commands; F1 or Ctrl+Shift+P the commands only.
- Tab indents in the code, also right after Esc closes the suggestions. To move on, press Esc and then Tab (Esc first closes suggestions, ends a snippet or clears a selection, so press it again), or Ctrl+M (Shift+Alt+M on macOS) so that Tab moves the focus.
- In the code: Ctrl+F finds and replaces, Ctrl+Alt+G goes to a line, Ctrl+D selects the next match of the selection too, Ctrl+Alt+Up or Down adds a cursor (so does Ctrl+click), Ctrl+Shift+[ and ] fold and unfold a block (Cmd+Alt+[ and ] on macOS), F8 goes to the next problem.
Connect from the sync status in the top bar ("Not connected"), the empty workspace, or Settings. You need a repository (private: a public one gets a warning first). Both ways of connecting link to GitHub's new-repository page with Private chosen ("No repository yet? Create a private one on GitHub").
Sign in with GitHub (where the site owner has set it up, below). Once:
- Connect GitHub, then Sign in with GitHub. GitHub asks you to pick an account and to authorize ExecFlow: choose Authorize.
- Back in ExecFlow, if no repository is listed: choose "Choose a repository on GitHub", pick your account, choose Only select repositories, pick one repository (private; it can be empty), then Install. Come back to the ExecFlow tab: the repository shows up.
- Pick it and choose Connect. A repository owned by an organisation may need the organisation's owner to approve ExecFlow first.
- ExecFlow is a GitHub App that asks only for Contents: Read and write (and the Metadata read GitHub adds). It reaches only the repositories you installed it on, and only if you can reach them too; the list warns when it can reach more than one.
- The sign-in lasts 8 hours and renews itself (GitHub's refresh token lasts 6 months and changes at every renewal). By default the sign-in is forgotten when the tab closes. "Remember on this device" (off by default; leave it off on a shared computer) keeps it encrypted (AES-GCM with a non-extractable key) in its own IndexedDB database, so the next visit syncs by itself. Disconnect asks GitHub to revoke this device's token and deletes it here; if GitHub can't be reached, the token stops working by itself within 8 hours, or you can revoke ExecFlow in your GitHub settings (Applications, Authorized GitHub Apps). On a shared computer, also sign out of github.com: your GitHub session in the browser isn't ExecFlow's.
- What the relay sees: to sign in and to renew, the browser sends the one-time code (with the PKCE
verifier) or the refresh token to
/api/auth/*on this same site, which adds the app's client secret, asks GitHub, and passes the tokens back. It stores and logs nothing. Syncing goes straight from the browser tohttps://api.github.com. GitHub lists ExecFlow under your Authorized GitHub Apps, and the app's owner can see which accounts installed it; the owner has no private key for the app, so they can't act on your repositories without your token. Install apps only from owners you trust.
Use a token instead: the Connect dialog's other path (and the only one where the relay isn't
set up, e.g. a fork or npm run preview). Make a fine-grained personal access token for that one
repository with Contents: Read and write. The Connect dialog links to GitHub's new-token page
with the name, Contents and a 90-day expiry filled in; you pick the repository there.
- The token goes only to
https://api.github.com, in the Authorization header. By default it is kept in the tab's memory and forgotten when the tab closes. "Remember on this device" stores it encrypted (AES-GCM with a non-extractable key) in its own IndexedDB database; leave it off on shared computers. Disconnect, or "Sign out and clear this computer" in Settings, removes it. - A sync downloads what changed on GitHub and uploads what changed here as one commit. Ctrl+S and the sync status sync at once; with "Sync automatically" (Settings, on by default) a sync also runs a minute after the last change while the tab is in front. Only the tab that edits the workspace syncs.
- Each commit is named after the files it changes, for example
Add lab3/q2.c, update main.py and 2 more(at most 72 characters), withAdded:,Changed:andDeleted:lists below (one file per line, up to 20 per list, thenand N more) and aFrom: <browser> (ExecFlow)line last. A file name that could read as part of the title (one with a comma, "and" or quotes) is quoted there. To write your own title, choose "Sync now with a message..." in the command palette (F1) or "Sync with a message..." in Settings: what you type (one line, up to 72 characters) replaces the title of that one sync's commit, and the file lists stay. Ctrl+S and automatic syncs never ask. If there is nothing to upload, or the sync fails, no commit carries the message; ExecFlow says so and offers the text again next time. - A file changed on both sides keeps GitHub's version under its name, and yours is saved next to
it as
name.conflict-YYYYMMDD-HHMMSS.ext, here and in the repository: nothing is lost. The same happens when a sync brings in a new version of a file while you are typing in it: the tab shows GitHub's version and your typing is saved as the conflict copy. Until you open the copy (or dismiss the notice about it), the sync status in the top bar reads "1 conflict" (a warning, not "Synced") and opens the copy; the notice stays until you act on it. In the file list a copy's name is cut in the middle, so the time it was made and its extension stay readable. On the first sync, if this computer and the repository have different versions of the same file, you choose: merge (conflict copies), the repository's versions, or this computer's. - Offline, changes stay here and sync once the connection is back. When GitHub limits requests, ExecFlow waits as long as GitHub says, then twice as long, and stops after 3 tries.
Share link... asks how to share, then copies the link. Nothing is shared until you choose.
- Code link (the default; works without GitHub): the file's name and code, compressed, in
the link itself (
#code=1.<data>). The part after#is never sent to a server, so nothing is uploaded and anyone can open it. A link holds up to 8000 characters, so chat apps keep it whole; a file too long for one says so. Copy with title copies it as a titled link ("Open main.py in ExecFlow") for documents and mail, and Show QR code draws it to scan from a screen. Opening a code link shows it in a read-only editor first, with line numbers, highlighting and its flowchart, and a Run of its own: the program runs with your limits and gets typed input, and whatever it writes is dropped, so trying it never touches your files. Add puts it in your files under a free name (or, when the same file is already there, opens that one), and it never runs by itself. Closed without adding, the notice offers it again. Damaged links, links whose content would unpack beyond 256 KB, names that aren't a single safe file name, and text that isn't plain text are refused; hidden characters in a name or the code are shown as tags in the preview. - A folder in a code link (Choose files to download or share...): the ticked files under one
folder name (
#code=2.<data>), at most 50 files, within the same 8000 characters and 256 KB. Each path is checked as an import checks it (no.., no absolute paths or reserved names, at most 8 folders deep), and two files that would land on one name, or a file where a folder is, refuse the whole link. Opening one lists the files and previews each in the same read-only editor (Run there gets the folder's files); Add puts them in a new folder at the top. - People with access to the repository: the file's page on GitHub,
https://github.com/<owner>/<repo>/blob/<commit>/<path>, pinned to the commit of the last sync. It opens only for you and the repository's collaborators while the repository is private. The dialog says so when it is public, and says when it couldn't check (offline, or GitHub didn't answer and the connection doesn't record it). Nothing is sent to make it and no new permission is needed. A file with changes that aren't on GitHub yet, or that never synced, shows Sync now first, so the link always shows what you see. A read-only tab doesn't share; the tab that edits does. - Anyone with the link (a secret gist): ExecFlow copies the file into a new secret gist on
your GitHub account, only when you press Create link. GitHub's own words: "Secret gists aren't
private" (Creating gists):
anyone with the link can open it without signing in; it just isn't listed or searchable. The
gist holds the file's content under its name only (its folders stay private). Closing the dialog
before the request goes out (it can wait behind a sync) sends nothing. To
remove it, open the gist on GitHub (the dialog links to it) and delete it. Text files up to 512 KB;
binary and empty files are refused. The token needs permission to create gists:
- Sign in with GitHub: the site's owner adds the account permission "Gists" (below), and you sign in again once to approve it.
- A fine-grained token: the account permission Gists: Read and write (permissions for fine-grained tokens, "User permissions for Gists"). A classic token: the gist scope (scopes).
- Either way this lets the token create, change and delete any of your gists, not only the ones ExecFlow made. Without it, the repository link still works and the dialog says what is missing.
Without these steps the site still works: the Connect dialog shows only the token path.
On GitHub: Settings, Developer settings, GitHub Apps, New GitHub App (GitHub's guide).
- Name: unique on GitHub, at most 34 characters (e.g. "ExecFlow Sync" and your name). Description: "Saves your ExecFlow workspace to a GitHub repository you choose and opens it again on any computer. Your code runs in your browser; the app reads and writes files only in the repositories you install it on." With Gists on (step 6), add: "Share link also makes secret gists when you ask it to." Homepage URL: the production site.
- Callback URL: exactly
https://<production origin>/auth-callback, one URL per address the site answers on (while the site moves to a new address, one for the old and one for the new). Leave any option that allows matching other URLs (wildcards, subdomains, paths) off. - Expire user authorization tokens: on (the default).
- Request user authorization (OAuth) during installation: off. Enable Device Flow: off.
- Setup URL: empty; Redirect on update: off. Webhook: untick Active.
- Permissions: Repository, Contents: Read and write; check that Metadata shows Read-only. For Share link's public link (a secret gist), also Account permissions, Gists: Read and write; leave it at No access if students shouldn't make gists from ExecFlow (the repository link works without it). Everything else No access (no Organization permissions, no other Account permissions, no Workflows).
- Where can this GitHub App be installed: Any account (classmates install it on their own repositories).
- Create the app. Note its Client ID and its slug (the last part of its public page,
https://github.com/apps/<slug>). Generate a client secret and paste it straight into Cloudflare (step 10), never into a file, a chat or the repository. Don't generate a private key: sign-in doesn't need one, and it would let its holder act on every repository the app is installed on.
On Cloudflare: Workers & Pages, the project, Settings, Variables and Secrets (Cloudflare's guide), in the Production environment only:
GITHUB_CLIENT_ID(text),GITHUB_APP_SLUG(text),ALLOWED_ORIGIN(text): the exact production origin,https://and the custom domain, no trailing slash. While the site moves to a new address, list both, separated by a comma (at most 4, spaces around the comma allowed), for examplehttps://execflow.abhinesh.codes,https://code-editor.abhinesh.codes. Every entry must be an exact origin with no wildcard and no path; one bad entry turns sign-in off for every address (the Connect dialog then shows only the token path). Sign-in sends GitHub the callback of the address the student is on, so each listed address needs its own callback URL (step 2).GITHUB_CLIENT_SECRET, type Secret. Not in Preview: preview deployments are public, and their origin differs fromALLOWED_ORIGIN, so they refuse sign-in anyway.- Check the build's root directory is the repository root (so
functions/is deployed with the site), then redeploy: secrets apply from the next deployment. - Optional, with the custom domain on a Cloudflare zone: one WAF rate-limiting rule for paths
starting with
/api/auth/(for example more than 20 requests in 10 seconds from one IP: block). - If the secret may have leaked: generate a new one on GitHub, set it in Cloudflare, redeploy, then delete the old one on GitHub. After a security fix to the relay, delete old production deployments (their URLs stay reachable).
Adding Gists to an app students already use. In the app's settings (Permissions & events), set Account permissions, Gists to Read and write and save. Nothing changes for anyone until they approve it: GitHub says permission changes don't take effect for a user authorization "until the new permissions are approved", and that for account permissions the app prompts users to reauthorize (Modifying a GitHub App registration, "Changing the permissions of a GitHub App"; Approving updated permissions). In ExecFlow that means: a signed-in student who presses Create link gets a sentence saying the sign-in can't create gists yet; Disconnect, then Sign in with GitHub again, and approve on GitHub's page. Their sync keeps working meanwhile. A user access token only ever has what both the app and the user allow (Choosing permissions for a GitHub App). GitHub lists POST /gists for user access tokens only, with Gists write (Permissions required for GitHub Apps, "User permissions for Gists"). Removing the permission later takes effect at once.
Local testing with a separate dev app. Register a second, private GitHub App the same way, with
the callback http://127.0.0.1:8788/auth-callback, so the production app keeps its one exact
callback. Put its values in a .dev.vars file at the repository root (ignored by git, never
committed):
GITHUB_CLIENT_ID=<the dev app's client ID>
GITHUB_CLIENT_SECRET=<the dev app's client secret>
GITHUB_APP_SLUG=<the dev app's slug>
ALLOWED_ORIGIN=http://127.0.0.1:8788Then npm run build and npm run dev:pages, and open http://127.0.0.1:8788.
| Folder | |
|---|---|
src/core |
Shared types, paths, byte and text checks, languages, the error help table (error-help.ts, checked against __fixtures__/error-help.json) |
src/storage |
The workspace in IndexedDB, one editing tab at a time, import, zip export |
src/sync |
GitHub sync (one commit per push, conflicts kept as copies), Sign in with GitHub (PKCE, the token source, the repository list) |
server, functions/api/auth |
The sign-in relay: its logic and tests (server/github-auth.ts), and the four Cloudflare Pages Function routes that call it |
src/editor |
CodeMirror 6 editor sessions, diagnostics and suggestions (src/editor/data: the generated library lists) |
src/runner, src/workers |
The Python and C/C++ runtimes and their workers |
src/ui, src/theme, src/styles |
The workbench, the colour themes, the styles |
src/flowchart |
The flowchart: the tree-sitter grammar pack and its download, the per-language readers, the engine, layout, drawing and export |
src/about |
The About page (about.html), the release list (changelog.ts), What's new, and the three.js scene, whose chunks are cached only once /about is opened |
The page is cross-origin isolated (COOP and COEP), so programs can wait for typed input. Its
Content-Security-Policy allows scripts only from the site itself (no eval), plus Cloudflare's
Web Analytics beacon (static.cloudflareinsights.com/beacon.min.js, which Cloudflare adds at its
edge and which reports to the site's own /cdn-cgi/rum; see the Privacy page), and network
requests only to the site and https://api.github.com. The workers that run code get a stricter policy
(the site only), and Python's worker has storage, network, locks, messaging to other tabs and its
own postMessage removed before any program starts (a program can't send the page messages).
- Each file is at most 1 MiB; a workspace holds up to 2000 files and 50 MiB.
- A run stops after 15 seconds by default (time spent waiting for typed input doesn't count) or after 512 Ki characters of output. Both can be changed in Settings.
- Python has 512 MB of memory, C and C++ programs 256 MB. Compiling has 30 seconds per file plus 30 seconds to link.
- C and C++ use clang 22: C up to C23, C++ up to C++23, with exceptions.
- Python needs a one-time 13.5 MB download the first time it starts on a device.
- C and C++ need a one-time 29.3 MB download, offered in the Output panel the first time, and a browser whose WebAssembly has exception handling: Chrome or Edge 137, Firefox 131, Safari 18.4, or newer.
- The editor's C and C++ suggestions are still read from clang 8's headers, so a few names that are new in C++20 and later aren't suggested yet.
- Not supported: matplotlib plots, programs that open network connections.
- Binary files, files with mixed line endings and other files that aren't plain UTF-8 text are kept read-only when they come from GitHub, and refused when imported.
- The browser may clear its storage when the disk is full (Safari: after 7 days without a visit). Settings has "Protect local data" (persistent storage) and Export to a .zip.
- Files save 400 ms after you stop typing. When the page is closed or reloaded sooner, the unsaved text is also kept in the browser's localStorage and saved on the next visit (as a conflict copy if the file changed meanwhile); "Sign out and clear this computer" removes it too.
- GitHub sync: an empty repository can only be started on its default branch; changes under
.github/workflows/need a token with the Workflows permission, so they stay here; repository paths that can't be file names here (reserved or unsafe names) are left out and reported.
The site's Privacy page says what ExecFlow keeps and
sends; Terms are the rules for using it. Both are linked
from Settings. The build writes /licenses.txt with every licence text the site's files ship under
(vite.config.ts, thirdPartyLicenses); a bundled npm package without a licence file stops the build.
What changed in each release: CHANGELOG.md, or the
About page on the site. Releases are listed in
src/about/changelog.ts, which writes CHANGELOG.md (node scripts/write-changelog.mjs) and the
About page's list; a release also bumps version in package.json.
src/about/site.ts holds what search engines and link previews read, and vite.config.ts applies it
at build time: each page's canonical link and Open Graph and Twitter card tags (from the page's own
title and description), sitemap.xml, and the home page's JSON-LD (in index.html; no ratings or
reviews). public/robots.txt names the sitemap. The social card is
public/media/social-card.<hash>.png, drawn by node scripts/make-social-card.mjs. Unknown
addresses get 404.html with a real 404; public/_redirects serves the editor at /auth-callback,
where GitHub returns after sign-in, and vite preview copies both so the end-to-end tests see them.
Since 0.12.0 the site's address is https://execflow.abhinesh.codes; the old one,
https://code-editor.abhinesh.codes, serves the same build while students move. Browser storage
belongs to one address, so at the old one a notice offers Move my files: the files go to the new
address in the browser, as a .zip handed over with postMessage (each side takes messages only from
the other's exact origin and window), and the new address imports them with the normal zip import
after asking. Files also stay at the old address. The editor at / is cross-origin isolated, which
cuts the link between two windows of different origins, so the hand-over happens at /move: the
same editor served without Cross-Origin-Opener-Policy and Cross-Origin-Embedder-Policy (the
/move rule in _headers, from vite.config.ts). The two addresses are build-time constants
(__MOVE_FROM__, __MOVE_TO__; the MOVE_FROM and MOVE_TO environment variables override them,
which the end-to-end tests do). Code: src/core/move-protocol.ts, src/ui/address-move.ts. A 301
from the old address to the new one ends the move (the old address's notice then never shows).
ExecFlow bundles or downloads the following. Their licences apply to their parts.
| Software | Licence | Used for |
|---|---|---|
CodeMirror 6 and Lezer (@codemirror/*, @lezer/*), with style-mod, w3c-keyname, crelt, @marijn/find-cluster-break |
MIT | The editor |
| idb | ISC | IndexedDB access |
| Pyodide 314.0.7 (includes CPython, PSF licence) | MPL-2.0 | Python |
| numpy 2.4.6 | BSD-3-Clause (with 0BSD, MIT, Zlib and CC0-1.0 parts) | Python package |
| pandas 3.0.2 | BSD-3-Clause | Python package |
| python-dateutil 2.9.0.post0 | Apache-2.0 or BSD-3-Clause | Python package (pandas) |
| pytz 2026.1.post1, six 1.17.0 | MIT | Python packages (pandas) |
YoWASP runtime (the JavaScript side of @yowasp/clang 22.0.0-git20542-10), vendored in src/vendor/yowasp-clang |
ISC (licenses/yowasp-runtime-LICENSE.txt) |
C and C++: running the compiler in the browser |
| LLVM 22: clang and lld (YoWASP's build), in the C/C++ pack | Apache-2.0 WITH LLVM-exception (licenses/llvm-22-LICENSE.TXT) |
C and C++: compiling and linking |
| libc++, libc++abi, libunwind and compiler-rt 22 (LLVM, wasi-sdk-33's exceptions build), in the C/C++ pack | Apache-2.0 WITH LLVM-exception (licenses/libcxx-22-LICENSE.TXT, libcxxabi-22-, libunwind-22-, compiler-rt-22-) |
C++ standard library and exceptions |
| wasi-libc (commit 161b3195, as wasi-sdk-33 pins it; built from musl and cloudlibc), in the C/C++ pack | Apache-2.0 WITH LLVM-exception, Apache-2.0 or MIT; musl's parts MIT, cloudlibc's BSD-2-Clause (licenses/wasi-libc-*) |
C library |
libc++ 8 and libc++abi 8 headers (binji/wasm-clang's sysroot, pinned by hash in scripts/gen-c-completions.mjs) |
MIT or University of Illinois/NCSA, dual licensed (licenses/libcxx-8-LICENSE.TXT, licenses/libcxxabi-8-LICENSE.TXT) |
The C and C++ names in suggestions |
TASA Orbiter (@fontsource-variable/tasa-orbiter) |
SIL Open Font License 1.1 | Font: the interface and the About page's text |
Geist Mono 1.8.2 (Vercel's release, cut to Latin by scripts/subset-geist-mono.py, in src/styles/fonts/) |
SIL Open Font License 1.1 (licenses/geist-mono-1.8.2-OFL.txt) |
Font: code, output and file names (its coding ligatures, Stylistic Set 11, only with "Joined symbols" on), the About page's labels and code |
Geist (@fontsource-variable/geist) |
SIL Open Font License 1.1 | Font: the social card image (scripts/make-social-card.mjs) |
JetBrains Mono (@fontsource/jetbrains-mono) |
SIL Open Font License 1.1 | Font: the social card image (scripts/make-social-card.mjs) |
Phosphor Icons (@phosphor-icons/core) |
MIT | Icons |
Workbox (through vite-plugin-pwa) |
MIT | Offline service worker |
| web-tree-sitter 0.27.1 | MIT | Flowchart: reading the code |
tree-sitter-c 0.24.1 (its .wasm) |
MIT | Flowchart: the C grammar |
tree-sitter-cpp 0.23.4 (its .wasm) |
MIT | Flowchart: the C++ grammar |
tree-sitter-python 0.25.0 (its .wasm) |
MIT | Flowchart: the Python grammar |
| three.js 0.186.1 | MIT | The About page's 3D scene |
| uqr 0.1.3 | MIT | Share link's QR code |
| Pocket Run (same author) | MIT | The runtimes, theme engine and console were adapted from it |
The colour themes in Settings use the published palettes of these themes, expanded onto ExecFlow's colours and adjusted where a colour pair would be hard to read. The table lists all 43 palette themes; High contrast, like ExecFlow Signal (the default), ExecFlow Deep Field and ExecFlow Slate, is ExecFlow's own:
| Theme | Source | Licence |
|---|---|---|
| Tokyo Night, Tokyo Night Storm, Tokyo Night Day | folke/tokyonight.nvim | Apache-2.0 |
| Catppuccin Mocha, Catppuccin Macchiato, Catppuccin Frappe, Catppuccin Latte | catppuccin/palette | MIT |
| Dracula | draculatheme.com/spec | MIT |
| GitHub-style Dark, GitHub-style Light | primer/github-vscode-theme | MIT |
| One Dark Pro | Binaryify/OneDark-Pro | MIT |
| Rose Pine, Rose Pine Moon, Rose Pine Dawn | rose-pine/rose-pine-palette | MIT |
| Nord | nordtheme/nord | MIT |
| Gruvbox Dark, Gruvbox Light | morhetz/gruvbox | MIT |
| Kanagawa, Kanagawa Dragon, Kanagawa Lotus | rebelot/kanagawa.nvim | MIT |
| Everforest Dark, Everforest Light | sainnhe/everforest | MIT |
| Ayu Dark, Ayu Mirage, Ayu Light | ayu-theme/vscode-ayu | MIT |
| Night Owl | sdras/night-owl-vscode-theme | MIT |
| Solarized Dark, Solarized Light | altercation/vim-colors-solarized | MIT |
| Vesper | raunofreiberg/vesper | MIT |
| Poimandres | drcmda/poimandres-theme | MIT |
| Vitesse Dark, Vitesse Light | antfu/vscode-theme-vitesse | MIT |
| Flexoki Dark, Flexoki Light | kepano/flexoki (stephango.com/flexoki) | MIT |
| Nightfox | EdenEast/nightfox.nvim | MIT |
| Horizon, Horizon Bright | jolaleye/horizon-theme-vscode | MIT |
| Material, Material Palenight, Material Ocean, Material Darker, Material Lighter | kaicataldo/material.vim (the Material Theme's palette) | MIT |
| High contrast | ExecFlow (this repository) | MIT (LICENSE) |