Method Budget

Method Budget is a free, open-source desktop app for building and running production budgets: topsheet, accounts and detail lines, fringes, globals, groups, charges and credits, versions and cost reports. It keeps your budgets as plain, documented files on your own disk, works offline, and never needs an account. No subscription, and your budget is a file you own.

Highlights

• Every number explains itself. Pick any total and trace it down to the lines, fringes, cutoffs and rounding steps that make it up. Money is kept in whole cents, so the topsheet always adds up.
• Bring your budgets with you. Open the budget exports other budgeting tools write (JSON, XML, .xlsx spreadsheet or tab-delimited), department spreadsheets and accounting exports. Each import is checked figure by figure against the totals in the file. See Importing.
• Your budget is an open file. Budgets are .mthd files: plain, documented JSON (docs/FORMAT.md). Any tool can read them, they diff cleanly, and you are never locked in.
• Keyboard first. Drill into an account, climb back to the topsheet, step between accounts, fill down and move rows without reaching for the mouse.
• Scriptable. The method-budget command line runs the same engine with no window, and a git merge driver combines two people's edits to one budget.

Yours to keep

• Free, for good. Open source under MIT or Apache-2.0. No subscription, no account.
• Your file, on your disk. Budgets are .mthd files with a published specification, so you can open them in twenty years, whatever happens to any vendor or to this project.
• Works offline. Nothing is uploaded. The app goes online only to check for its own updates, and you can turn that off.
• Nothing invents your numbers. There is no generative AI in the app: every figure comes from what you typed and the rules you set.

Status, honestly

Alpha, ready for testing. It's tested against thousands of figures, but you will find rough edges: keep a copy of budgets that matter, and check numbers before they leave the room.

Platform	Built	Signed	Tested by hand	Updates itself
macOS, Apple silicon	Yes	Yes, notarized by Apple	Yes	Yes
macOS, Intel	Yes, from 0.6 (one app for both kinds of Mac; 0.3 to 0.5 were Apple silicon only)	Yes	Not checked	From 0.6; a copy of 0.2 updates to it
Windows (x64)	Yes	Not yet	Not yet	Not yet
Linux (x64, .deb and AppImage)	Yes	Not applicable	Not yet	Not yet

Not there yet: tested Windows and Linux builds, updates in place on those two, and starter templates with charts of accounts (being written now). The roadmap has the rest. Windows and Linux: help us get there.

Features

The list below is generated from docs/features.toml by python3 scripts/site.py, which also writes the list on the website. Edit that file, not this section.

Budgeting engine

• Topsheet, accounts and detail lines. The familiar three levels, with every total rolling up live as you type.
• Money to the cent. Every amount is kept in whole cents and rounds the way production budgets have always rounded, with an exact mode if you want one.
• Formulas and globals. Amount, quantity and rate cells take formulas and named globals; change a global and every line that uses it follows.
• Schedule-linked quantities. Read a schedule's day counts (shoot days, days per location, set, week or cast member) and set your globals from them, after a review of every change.
• Currencies. Any line can be in its own currency, converted to the budget's base currency at rates you set.
• Groups and what-ifs. Tag lines into groups, leave a group out of the total to see a what-if, and get back to the exact cent when you put it back.
• Explain this number. Trace any total down to the lines, fringes, cutoffs, ranges and rounding steps that make it up.
• Overtime helper. Work out a day or a week of straight time, overtime bands and sixth and seventh days, then write the pay into the line.
• Fast on big budgets. An edit recalculates in about 5 ms on a 5,000-line budget.

Fringes, globals, charges and credits

• Fringes with cutoffs and ranges. Percent and flat fringes, cutoffs per earner, fringe ranges across several lines, unit-hour flats and four ways to post them.
• One cutoff per person. Name the person on each of their lines, in any account, and a fringe cutoff such as a wage base applies once to everything they are paid.
• Globals with details. Give a global a description, a unit and decimals, show it by name in cells, and see the formulas behind a selection.
• Contractual charges. Percent and flat charges with exclusions, a live preview while you type, and the percent shown on the topsheet if you want it.
• Credits. Credit rows show gross, excluded fringes, net and how far you are from a cap.
• Incentive estimates by location. Limit a credit to the locations where the money is spent and see every program's estimate side by side, applied or not, from rates, caps, minimum spends, broker's fees and shared caps you enter yourself, and print them location by location.
• Incentive what-ifs. See what each incentive program gains or loses if lines were shot at another location, then move them in one step you can undo.
• Apply panel. Select lines, then tick fringes, groups, sets and locations on or off, with live totals for the selection.
• In-use counts. Every setup list shows how many lines use each item and what they cost, warns before you delete one in use, and finds them in a click.
• Your own rate tables. Keep rate tables of your own (classifications with a rate per hour, day or week and the dates each is in effect), type them in or import them from a spreadsheet, and pick a classification on a line to fill its rate; the line remembers where the rate came from and tells you when the table changes.

Editing, split view and history

• Keyboard-first grid. Drill in, climb out, step between accounts, fill down and move rows without touching the mouse; a shortcut sheet lists every key.
• Type-ahead and add on the fly. Units, currencies, sets, locations and globals complete as you type, and a new one can be added right from the cell.
• Never lose work. Autosave into the file, recovery copies for untitled budgets, rolling backups and a restore after a crash.
• Budget tabs and split view. Open several budgets as tabs, each with its own undo, and put two side by side in one window.
• History list. Every undo step is listed by name and time; click one to go back to it, or save it as a version.
• Find and replace. Search descriptions, account numbers, fringes, globals, groups, notes and formulas, then replace only in the results you tick, as one undo step.
• Copy rows with everything on them. Rows keep their fringes, groups, notes, style and ranges when copied, even between budgets, with a review of what the paste will change.
• Notes. Dated notes on lines, accounts and categories, and a notes list that works as a review checklist.
• Signed and notarized Mac app. The Mac app is signed and notarized by Apple, so it opens like any other app with no extra security step.

Versions, compare, diff and merge

• Named versions. Save, rename, annotate and restore versions, all kept inside the budget file.
• Compare up to 16 budgets. Versions or other files side by side at topsheet and account level, with sum, average and variance columns, down to detail lines.
• Original and variance columns. Keep a locked baseline and see each account's change from it right in the grid.
• What changed. A plain-words diff of two budgets or versions: every changed line, field and setup item, with the money it moved.
• Three-way merge. Two copies that changed apart merge on their own where they touched different things; real clashes are listed for you to pick.
• Share-ready copies. Save a dated snapshot, optionally without notes or private info, that opens read-only and compares back against the original.
• Review files. A reviewer comments on lines, accounts and categories of a budget they can't change; the comments come back in a small file beside it, and you merge each one in as a dated note or set it aside.
• Small version history. Versions can be stored as compact patches, so ten versions of a large budget take about the space of one.

Actuals and cost reports

• Import actuals. Bring in transactions from CSV, tab-delimited or spreadsheet (.xlsx) accounting exports with a column mapping, duplicate checks and a review of unknown accounts.
• Cost report. Budget, actual to date, estimate to complete and variance by account, with each account's estimate method your choice.

Reports, PDF and spreadsheets

• Reports saved in the budget. Pick sections, accounts and layout, save them as named presets with header and footer fields, and print straight to PDF.
• Live preview. The setup dialog shows the printed pages as you change them, with page navigation and a jump list of sections.
• More than the topsheet. Category summaries, account detail, setup tables, chart of accounts, group totals, budget information and a notes list.
• Spreadsheet export. One spreadsheet (.xlsx) with topsheet, accounts, detail and setup tables, plus CSV and tab-delimited files for accounting.
• Spreadsheet import. Turn any department's spreadsheet (.xlsx), CSV or tab-delimited file into budget lines with a column mapping and a line-by-line check of the totals.
• Import from other budgeting apps. Open a budget from another program's JSON, XML, spreadsheet (.xlsx) or tab-delimited export, with a line-by-line check against that program's own totals.

Setup library and templates

• Start from another budget. Import setup items from any budget, with what they depend on, or start a new budget from a template.
• Personal setup library. Keep your fringes, globals, groups and the rest in a library file of your own and copy them in and out with a conflict review.
• Tag presets and line blocks. Save a set of tags or a block of lines once and apply or insert them anywhere.
• Rename everywhere. Rename a fringe, global, group or unit and every reference follows, formulas included, as one undo step.
• Renumber accounts. Change the account numbering pattern and preview every old and new number before it applies.
• Sub-budgets. Make a filtered copy by categories, accounts, groups, sets or locations, for a department or a unit.
• A sample budget to explore. The first time you open the app, an invented feature of about a million dollars opens as an untitled copy, with every feature in use; Help > Open Sample brings a fresh copy back any time.
• New project window. Start a budget from one window with its title, chart of accounts, schedule, currency, your setup library and setup packs, in a project folder of its own, ready to fill in. Duplicate a budget, or start a new one from a category or account.

Command line and git

• Open file format. Budgets are .mthd files: plain, documented JSON that diffs cleanly and that any tool can read.
• Scriptable command line. method-budget checks budgets, prints totals, draws reports as PDF, HTML or CSV, and exports and imports spreadsheets, with no window and no network.
• Batch edits. method-budget set and method-budget apply run edit scripts all or nothing, with a dry run that shows what would change.
• Git merge driver. Keep budgets in git and let method-budget merge-driver merge edits to different lines, flagging only real conflicts.

On the roadmap

• Windows and Linux, tested. Installers for both are built today; printing, keys and file types still need a hands-on check.
• Accessibility and translations. A full accessibility pass and the app in more languages.
• Work on a budget together. Several people in one budget at once, through a shared Dropbox or iCloud folder or a live link, with who changed what and undo that only takes back your own edits.
• Rate card lookup. Pick a union classification from public rate cards that come with the app and fill in the rate, with the source and effective date shown.

Install

Method Budget is a desktop app for macOS, one app for Intel and Apple silicon Macs, with Windows and Linux builds that have not been tested by hand yet. Download the Mac app from the latest release, or build it from source. docs/INSTALL.md covers building, installing on a Mac, the one-time security step for builds that are not notarized, and what signed releases need.

Build from source

Get the code:

git clone https://github.com/method-production-suite/method-budget.git

You need Rust (the version is pinned in rust-toolchain.toml, and rustup picks it up on its own). There is no JavaScript toolchain: no npm, no bundler.

cargo test --workspace            # the engine, the file format, the command line and the app
cargo run -p method-app           # run the desktop app

On Linux, install the WebKitGTK build packages first (listed in docs/APP.md). Installers (.app and .dmg, .msi, .deb and .AppImage) are built with the pinned Tauri CLI, as docs/INSTALL.md describes.

Command line quickstart

The method-budget command reads and writes budgets without the app: same engine, no window, no network. Install it from a checkout:

cargo install --path crates/method-cli --locked

Then:

method-budget new my-film.mthd                      # a starter budget
method-budget show my-film.mthd                     # the topsheet
method-budget check my-film.mthd                    # recalculate and report problems
method-budget totals my-film.mthd --json            # every total, in cents, for scripts
method-budget explain my-film.mthd net              # how a total is made up
method-budget report my-film.mthd --sections topsheet -o topsheet.pdf
method-budget export my-film.mthd --xlsx my-film.xlsx
method-budget diff old.mthd new.mthd                # what changed, in plain words

Every command, flag and exit code is in docs/CLI.md.

Budgets in git

Budgets are text with stable ids inside, so git can merge two people's edits. Tell git to use the merge driver:

echo '*.mthd merge=method-budget' >> .gitattributes
git config merge.method-budget.name "Method Budget merge"
git config merge.method-budget.driver "method-budget merge-driver %O %A %B %P"

Edits to different lines merge on their own; real clashes are left for you to settle in the app. Details: docs/MERGE.md.

Coding agents

method-budget mcp is an MCP server, so coding agents and other MCP clients can open, read and edit budgets with typed tools: lines, globals, fringes, charges, totals, explain, export, import and undo, all through the same engine and the same exact arithmetic as the app. It only touches files inside the folders you give it, writes atomically, won't overwrite a file someone else just saved, and has a read-only mode. Nothing is sent anywhere.

Register this command with your client as a stdio server:

method-budget mcp --root ~/Budgets

How to register it, every tool and the safety model: docs/MCP.md.

Importing

Method Budget reads the open files other programs export for their users, never their native files (CLEAN-ROOM.md).

From	Formats	What comes across
Other budgeting software	JSON (best), XML Advanced, .xlsx spreadsheet, XML Basic, tab-delimited	Accounts, lines, fringes, globals, groups, charges and credits; Basic XML has no groups or globals, tab-delimited has account totals only
Any spreadsheet	.xlsx, CSV, tab-delimited	Budget lines, with a column mapping
Accounting systems	.xlsx, CSV, tab-delimited	Actuals for cost reports, with a column mapping
Another Method budget	.mthd	Fringes, globals, charges, credits and other setup

In the app: File > Import Budget Export…. From the terminal:

method-budget import-export "Pilot budget.json" -o pilot.mthd

Every import ends with a review that compares each line, account, fringe and total with the figures in the file. Suppressed lines are not in the exports, and charge and credit rules arrive as the fixed amounts they came to.

File format

Budgets are pretty-printed JSON with a fixed key order, money as integer cents and decimals as strings, so the same budget always produces the same bytes. The full specification is docs/FORMAT.md. It is ours to document and yours to use: write tools that read or produce it.

Templates and charts of accounts

Any budget can be a template: File > New From Template starts a new budget from another one's chart of accounts, setup and settings without its lines, and File > Save as Template writes one. Starter templates with charts of accounts written for this project are being added now.

Clean room

Method Budget is an independent, clean-room project by the Method Budget contributors, not affiliated with Entertainment Partners or Movie Magic Budgeting. Trademarks belong to their respective owners. It uses no other vendor's code, templates, help text, icons or data, and reads budgets from other tools only through the open files they export. The rules every contribution follows are in CLEAN-ROOM.md.

Help build it

If you make films. The most useful help needs no code:

• Import an old budget's export and tell us about any figure that comes out different.
• Check the fringes and rate setups for your region and union, and tell us what's wrong or missing.
• Contribute a chart-of-accounts template or an invented sample budget.

Open an issue, or use Help > Report a Bug… in the app, which fills in the version for you. Please never attach a real budget, schedule or call sheet: an invented one that shows the problem (method-budget sample makes a large test budget) is always enough.

If you write code. Start with an issue labelled good first issue. Before you open a pull request, run the checks CI runs:

cargo fmt --all --check && cargo clippy --workspace --all-targets -- -D warnings && cargo test --workspace

Read CLEAN-ROOM.md first: it is short, and it is the one hard rule. Design choices and their reasons are numbered in docs/decisions.md, what comes next is in docs/ROADMAP.md, and how the project looks and sounds is in docs/BRAND.md.

Part of the Method Production Suite

Method Budget is one of the Method Production Suite's free, open-source tools for film and TV production.

License

Dual-licensed under MIT or Apache-2.0, at your option. Copyright (c) 2026 Method Production Suite Team and the Method Budget contributors. Contributions are accepted under the same terms. The third-party code the app and the command line ship, with its licences, is listed in THIRD-PARTY-NOTICES.md (generated by cargo xtask notices).