Projects

A saved workspace with a public URL and a secret edit key.

• Save as project creates it and needs an account: signed out, the button reads Sign in to save and takes you to sign in. The edit key stays in this browser only, hashed on the server.
• /p/<slug> is a read-only page anyone can open; /ide/<slug> opens it in the editor.
• Others see view only and can Fork an editable copy. You can rename, autosave (1.5 s after a change), and delete.
• Saves send only changed files; runs of a saved project reference it, so no source travels with the run.
• Signed in when you save? The project is yours: it is listed under your account and you can edit it from any browser.
• A lost key on a project saved while signed out means fork to keep editing. 30 projects per address per hour.

GitHub: import, commit and push

The rail's GitHub button (also Import from GitHub in the Projects dialog) opens one dialog with two jobs:

• Import into a new project: paste owner/repo or a GitHub URL; a URL with /tree/<branch>/<folder> imports just that folder. It becomes a saved project of yours (an account is needed). A project holds at most 16 files and 256 KB, so a bigger repository is refused with its size and a hint to import a subfolder. Dotfiles (.gitignore, .github/), symlinks, submodules and binary files are left out. The language is the one whose entry file (for example main.py) is at the folder's root; without one, the most common language's entry file is added empty, and the import says so. Public repositories import without connecting GitHub.
• Commit and push: connect GitHub once (Connect GitHub, which asks GitHub for access to your repositories), then give the repository, a branch (empty means the default branch; a new name creates the branch from it), an optional folder and a message. The files of the open project or workspace become one commit made as your GitHub account. Files are added or updated; nothing in the repository is deleted. An imported project remembers where it came from, so pushing back needs only a message. The repository must already have a first commit.

Flare keeps your GitHub token encrypted on the server and uses it only to talk to GitHub; it never reaches the browser. Disconnect in the dialog deletes it and revokes it at GitHub.

Sharing a project with people

The owner switches Collaborate on and invites people with a link (/join/<token>, valid 7 days by default, revocable). Whoever opens it signs in and joins as an editor (can change files, name and input) or a viewer (read only). The number of members a project can hold comes from the owner's plan (Teacher 10, Startup 25, see Pricing); the owner changes roles and removes members, and members can leave. While collaboration is on, the edit key is ignored: every change comes from an account.

Editing together

Open /ide/<slug> of a live project while signed in and you are in the room: everyone's keystrokes merge as they type (a CRDT, so nothing is overwritten), you see each other's cursors with names, the footer shows live · N here, and its right side lists the avatars of the people who have the same file open as you (hover: editing or viewing). The header avatars show everyone in the room, whichever file they are on. Viewers see everything but cannot type. The room saves to the project two seconds after the last keystroke and keeps a log of every change in between, so a crash loses at most that window. Rooms close after ten minutes without anyone in them. Language-server diagnostics keep working on the shared text; runs use what is in the room, not an older save. When any member presses Execute, the result appears in everyone's output pane and Log, tagged with who ran it.

The Collaborate button in the editor bar does all of this without the API: the owner switches live editing on, picks a role and creates an invite link to copy, sees pending links and revokes them, changes members' roles or removes them; members see the roster and can leave.

Who pays

Hosting a live project needs a paid plan (Teacher, Startup or Custom); joining one is free for everyone. On Free the switch in the Collaborate dialog is disabled with a link to Pricing. The server decides from its own records: a payment counts only after the provider confirmed it, so a browser cannot talk its way in.

Teams

One account pays, several people host. On a plan with seats (Teacher: 40, Startup: 5, the owner included) the account menu shows Team: /teams creates your team (one per owner) and /teams/<slug> shows the roster with a seat counter, invite links (same /join/<token> links as projects, 7 days by default, revocable), remove, leave and delete. Whoever joins takes a seat; when every seat is taken the next join is refused until one is freed. While you are on a team whose owner's subscription is active, you can switch live editing on for your own projects without paying yourself; leave or get removed and that ends on the next request. The server decides from its own rows, never from the browser (REQ-0007). A person can belong to several teams but own only one; the owner never sees members' personal projects.

Team projects. In the IDE's Projects dialog, the + New project row offers Team: … next to Just me when you are on a team. A project saved to a team belongs to the team's owner and every member edits it without an invite or a key (a viewer row on the project still makes that person read-only); it is listed on the team page and under My projects with the team's name; only the owner switches it live or deletes it. Leave the team or get removed and it is gone from your list; deleting the team keeps its projects with the owner. Forks are personal.

Join by email domain. The owner can name one domain on the team page (say school.ac.ke). Anyone signed in through Google or GitHub with an address at that domain then sees the team under /teams with a Join button; joining takes a seat like a link does. Password accounts cannot join this way because their address is not verified. Clearing the domain stops further joins and keeps the people already on the roster.

Extra seats. Startup includes five seats; more are bought at checkout (an Extra seats field on the Startup card when Stripe is the payment provider) and later changed in Stripe's own portal. The server learns the count only from Stripe (the seat line item's quantity, verified on return from checkout and by signed webhooks) and stores it on the subscription; the team's seat counter and the cap on joins read plan seats plus bought seats from that row and nothing else. Pesapal orders carry no seat quantity, so extra seats are Stripe only.

Teacher view. The owner's team page has an Activity table: for each person, how many projects they own, how many runs they made in the last seven days, and when their last run was with its language and verdict. Nothing more: no source, no output, no way into a personal project. Work meant for the teacher is saved to the team.

Plans

Pricing lists the four plans. Free: 250 saved projects, 1,000 runs a day, join live projects, supported by ads that never appear inside the editor. Teacher: unlimited projects, host live projects with 10 people each, no ads. Startup: five seats, 25 collaborators per project. Custom: your own limits and invoices, by quote. Yearly billing is about 20% less than monthly. The compiler API and AI allowances on the cards are marked soon: they describe what each plan will include when those features ship.

Prices are in USD; a browser set to Kenya sees Kenyan shillings, converted on the server from one daily rate and rounded to figures like KES 1,999, and the switch above the cards changes currency and billing period. Pay by card, M-Pesa or bank through Pesapal (a prepaid month or year; nothing renews by itself) or by card through Stripe (renews until cancelled), whichever the server is set up with. When you reach the Free project cap, saving a new project answers 402 plan_limit with a message saying so.