Open-source exit waterfall engine and dashboard. Given a cap table and an exit value, spillpoint works out who gets what: preferences, participation and caps, conversions and options. It also finds every breakpoint where the payout curve bends or jumps, and explains each one in plain English.

Try it

spillpoint.github.io/spillpoint runs in your browser. You can:

• Start from a fictional example, a blank cap table, a blank company to build from its rounds, or a file you saved.
• Open an export from your cap table software: in Open Cap Format, as a .zip or its files, or an OCX workbook (.xlsx). The page shows what it read, and asks about anything the format doesn't say, such as the order the preferred is paid in, before the cap table is used. "Copy a summary to share" copies what the page found as counts and codes, never a name, an amount or a date, so you can ask for help with an export without sharing your cap table.
• Add the next round to a cap table you entered or imported. The cap table becomes where the company starts, and the Rounds tab builds the round on it. If an import's SAFEs or notes can't be paid at a sale, it offers a round that converts them.
• See what you get at any exit value, against your share of the company, and where your payout starts.
• Follow the payoff curves by holder or by class. Every breakpoint is marked and explained, including how it changes your payout. Where a carve-out alongside the preferences makes payouts curve, the curves follow it.
• Edit the cap table:
  • holders
  • common stock
  • options at each strike
  • warrants, for common or a preferred series, at each strike
  • preferred series, with their preference, participation and cap, and any cumulative dividends
  • the order the preferred series are paid in
  • one group of series that convert together
  • the unissued option pool
  • SAFEs and convertible notes still outstanding at the sale
• Set the sale's terms under Exit terms, even when the cap table is built from rounds:
  • its date, which notes' interest and cumulative dividends accrue up to
  • a management carve-out, in tiers, paid before the preferences or alongside them
  • escrow and earnouts, as a schedule of payments. The Payouts tab shows each holder's take of each payment, and warns when a later payment lowers what someone has been paid so far.
• Build the cap table from the company's history on the Rounds tab: shares issued, the option pool, grants, warrants, SAFEs and convertible notes, and priced rounds with their pool top-ups, pro-rata, anti-dilution, pay-to-play and cumulative dividends. Each event shows what it did, what it did to your share, and the cap table after it. The fictional example, Millrace Robotics, opens from its ten events.
• Save the cap table, or the rounds that build it, to a file on your computer, and open it again.

Your cap table stays in your browser. GitHub Pages serves the page, and sees the visit as it would for any site. After that, the page makes no network requests and tells the browser to block any it might try. Nothing is kept anywhere unless you save a file.

The page doesn't build a few combinations within a round: the engine's README lists them. Anything it doesn't handle is refused with a message saying so, never quietly ignored.

The charter and the signed documents govern, not this tool.

The engine

The engine is on npm as spillpoint. It runs entirely on your machine, with no network access, so your cap table never leaves it. From version 0.1.0 it also builds a cap table from a company's rounds: SAFEs and notes converting, priced rounds with their pool top-ups, pro-rata, anti-dilution and pay-to-play. From 0.2.0 it also pays warrants, cumulative dividends, management carve-outs, escrow and earnouts, and SAFEs and notes still outstanding at a sale. From 0.3.0 it also converts SAFEs and notes in a round that triggers anti-dilution or has pay-to-play, and a post-money SAFE beside notes or other SAFEs; and it takes a carve-out as a term of the sale. From 0.4.0 it also reads an Open Cap Format export into a cap table, with a report of what it read and the terms the format leaves open. From 0.5.0 it also builds the next round on a cap table you already have, entered or imported, and pays SAFEs beside a capped note at a sale; where the documents leave two answers open, it says so rather than pick one. From 0.6.0 it also reads an OCX workbook, the Open Cap Table Coalition's spreadsheet format, in its 0.4/0.5 and 0.7 layouts; no Carta export has been tested yet. And its refusals say what isn't modeled, no longer when it might be. From 0.7.0 its names are settled: everything it hands back holds only what its types list, and 0.7.0 is the last release that can break code written for an earlier one. Its README lists what it still refuses, and every name code can match on, each stable from 1.0.

Open Cap Format (OCF) is developed by the Open Cap Table Coalition: https://open-cap-table-coalition.github.io/Open-Cap-Format-OCF/. spillpoint reads files in that format.

OCX is developed by the Open Cap Table Coalition: https://github.com/Open-Cap-Table-Coalition/ocx. spillpoint reads files in that format.

Coming next: 1.0, with the same API as 0.7.0, at its own domain. Two behaviors change, both fixes: prepare works on its own frozen copy of the cap table, and toCents can't show an amount that's exactly a half cent a cent low (see notes/release-1.0.md). It waits on an outside waterfall that matches spillpoint's, and a few outside users.

The fund waterfall

spillpoint.github.io/spillpoint/fund does the same for a fund: how a distribution splits between its LPs and its GP, tier by tier, with every breakpoint explained and, at the fund's last distribution, any clawback the GP owes. From 0.2.0, with the fund's LPs listed, it gives each LP's share: rounded down to the cent as it would be paid, and downloadable as a CSV. From 0.3.0 LPs can be in classes, each with its own fee rate and carry and running the waterfall on its own, with its own clawback; and can join at later closes, with the equalization between the LPs at each close worked out and downloadable too. From 0.4.0 it works out management fees, entered as fee calls or from a schedule, a rate on commitments with steps by date, its calls listed beside the cash flows; and a fee call before a later close is each LP's own, the joining LP paying its back fees to the manager. Its engine is on npm as spillpoint-fund (0.4.0). It runs in your browser too, and the fund's documents govern, not the tool.

In this repository

• packages/engine: the spillpoint npm package.
• packages/fund: the spillpoint-fund npm package, with its own rules, cases and reference.
• apps/fund: the fund page. Run it locally with pnpm --filter @spillpoint/fund dev.
• apps/dashboard: the page above. Run it locally with pnpm install && pnpm dev.
• cases: the locked test cases, each with its inputs, expected values and a plain-English derivation.
• reference: an independent calculator, using exact fractions and a different method, that produced the expected values.
• docs: the rules (SPEC.md) and every modeling choice with its default (ASSUMPTIONS.md).
• scripts/ocf-check.mjs: checks an Open Cap Format export, pnpm ocf-check export.zip, or an OCX workbook, pnpm ocf-check export.xlsx (0.6.0), and prints only counts and codes, never a name, an id, an amount or a date, so what it prints can be shared without the cap table. Needs Node 22.18 or later.
• : what kinds of cell an OCX workbook's columns hold, , as counts and kinds only, never a value, so it can be shared without the cap table. Needs Node 22.18 or later.

Licensed under Apache-2.0.