Skip to content
strange-exePublic

About

ExecFlow is a code editor in the browser for students. It runs Python (Pyodide) and C/C++ (LLVM in WebAssembly) on your own device. It works offline as an installable web app, turns code into flowcharts, makes encrypted short links and QR codes for sharing, and can sync to a private GitHub repository.

Topics

Resources

Stars

0 stars

Watchers

0 watching

Forks

Latest commit

 

History

306 Commits

Folders and files

NameName
Last commit message
Last commit date
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

ExecFlow

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 NameError with a suggested name, str + int, a missing colon or bracket, an undeclared identifier, a missing #include or ;, 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 Python sys.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 (main for 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 for goto. 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).

Running it

Needs Node 24.18 (see .node-version) and npm 11.

npm ci --ignore-scripts
npm run dev

npm 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

Continuous integration

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.

Suggestions

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 import and from, and a module's members after math. or from math import. Your own modules (helpers.py beside 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, and std:: names in C++. After your own using 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 (print typed in full), Enter makes a new line unless an arrow key picked it. Otherwise Enter accepts what is on top: n = i becomes n = id when the file has no i, and a snippet such as def, if or main still expands (after int, main writes 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.

Keyboard

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.

Keeping the files on GitHub

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:

  1. Connect GitHub, then Sign in with GitHub. GitHub asks you to pick an account and to authorize ExecFlow: choose Authorize.
  2. 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.
  3. 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 to https://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), with Added:, Changed: and Deleted: lists below (one file per line, up to 20 per list, then and N more) and a From: <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.

Sharing a file

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.

Setting up Sign in with GitHub (the site's owner, once)

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).

  1. 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.
  2. 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.
  3. Expire user authorization tokens: on (the default).
  4. Request user authorization (OAuth) during installation: off. Enable Device Flow: off.
  5. Setup URL: empty; Redirect on update: off. Webhook: untick Active.
  6. 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).
  7. Where can this GitHub App be installed: Any account (classmates install it on their own repositories).
  8. 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:

  1. 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 example https://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).
  2. GITHUB_CLIENT_SECRET, type Secret. Not in Preview: preview deployments are public, and their origin differs from ALLOWED_ORIGIN, so they refuse sign-in anyway.
  3. 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.
  4. 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).
  5. 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:8788

Then npm run build and npm run dev:pages, and open http://127.0.0.1:8788.

How it is put together

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).

Limits

  • 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.

Privacy, terms and licences

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.

Search and sharing

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.

The move to a new address

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).

Third-party software

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)

About

ExecFlow is a code editor in the browser for students. It runs Python (Pyodide) and C/C++ (LLVM in WebAssembly) on your own device. It works offline as an installable web app, turns code into flowcharts, makes encrypted short links and QR codes for sharing, and can sync to a private GitHub repository.

Topics

Resources

Stars

0 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages