FAQ — using EPICAC, the free online solver

Every Problem Is Constraints And Cells — an Excel-Solver-style optimizer that runs entirely in your browser. Three engines — Simplex LP/MIP (HiGHS, compiled to WebAssembly), GRG Nonlinear, and Evolutionary (both written in Rust, compiled to WebAssembly) — plus live telemetry, run history, and ensemble insights that Excel never gave you. Nothing is uploaded anywhere; your data stays on your machine.

The same way you'd set up a model for Excel's Solver. There are no magic headers — the solver reads cells, formulas, and the model you configure in the panel. The conventions that make life easy:

• One contiguous range of decision variables. Plain numbers (starting guesses), not formulas — e.g. units to make in B4:D4. A column layout (item, decision, data…) like the Knapsack template is the most readable pattern.
• A single objective formula cell that depends on the variables, usually via SUMPRODUCT — e.g. =SUMPRODUCT(B4:D4,B5:D5) for profit.
• One row per constraint: a formula cell for the left side ("used"), and a constant or cell for the right side ("capacity"). Ranges pair elementwise: F7:F9 ≤ H7:H9 is three constraints.
• Label everything.Labels are ignored by the engines but flow into constraint reports and telemetry, so "Labor ≤ 450" reads as itself, not as "c3".
• Keep models within columns A–Z and rows 1–250 (the grid size). Import reads the first sheet of the workbook.

The fastest way to learn the shape: download a template .xlsx and swap in your data. Formulas are imported (cellFormula), so a workbook that solves in Excel usually drops straight in. You can also paste cells directly from Excel/Google Sheets into the grid.

The grid itself (powered by HyperFormula) understands most Excel functions. The solver engines compile your formula graph to fast WASM bytecode and support the subset that covers virtually all Solver models:

Operators: + − * / ^ % and comparisons (=, <>, <, <=, >, >=) — Excel semantics, including -2^2 = 4.

This list also lives behind the ƒx functions button next to the formula bar. If a formula in the objective/constraint dependency chain uses something else, the solve fails with a clear message naming the function — restructure with the supported set (SUMPRODUCT + IF covers a remarkable amount of ground). Yes, both SUM and SUMPRODUCT are fully supported — SUMPRODUCT is the workhorse for linear models.

• Simplex LP — everything is linear (SUMPRODUCT-style formulas). Exact, proven optimum in milliseconds, handles int/binvia branch & bound, and produces shadow prices and reduced costs. The solver checks linearity automatically and tells you if the model isn't.
• GRG Nonlinear — smooth curved formulas (squares, ratios, exponentials). Finds a local optimum from your starting values; raise multistart to sample several starts. Integer constraints are only approximated (rounded at the end).
• Evolutionary — anything goes: IF/MIN/MAX cliffs, AllDifferent, wild non-convexity. No optimality proof, but excellent answers with a bonus: a whole population of good solutions powering the Insights tab. Give every variable bounds for best results.

<= >= = compare a formula/cell (or range) to a number, cell, or range. int forces variable cells to integers, bin to 0/1, and alldiff makes a group of variables take distinct integer values (Evolutionary engine only). Variable-vs-constant constraints are also folded into bounds automatically.

• Evolutionary: per-generation best / mean / worst objective, diversity (average spread of the population per variable — when it collapses, the search has committed), feasible share, and stagnation count. The final population (top N) is kept for the Insights tab.
• GRG: per-iteration objective, constraint violation, gradient norm (convergence = it approaching zero), step size, penalty weight μ, and restart index.
• LP/MIP: the raw HiGHS log (presolve, simplex/branch-and-bound progress), then a full sensitivity report — shadow prices (what one more unit of a binding resource is worth) and reduced costs.
• Every run exports as JSON (full trace + model + config snapshot) or CSV (per-iteration table) from the Results tab or the Runs page.

Yes — GA and GRG use a seedable deterministic RNG, and the run record stores the seed, full config, and a hash of the sheet. Same data + same config + same seed = identical trajectory, bit for bit. Change the seed to test how robust your answer is (the Runs page overlays convergence curves for exactly this).

The hard cap is 1000 variables; a few hundred is comfortable. LP models solve in milliseconds at that scale. Evolutionary cost scales with population × generations × formula complexity — the Rust bytecode evaluator typically does tens of thousands of full-sheet evaluations per second, so 200-variable models run in seconds.

For LP: it shouldn't, beyond tie-breaking between equally-optimal solutions. For GRG/Evolutionary: both tools are heuristic and depend on starting points, seeds, and option settings — compare objective values, not variable-by-variable equality. If this tool finds a betterobjective than Excel did, that's not a bug; it happens more often than you'd think.

Officially: Every Problem Is Constraints And Cells — which is also this tool's honest worldview. Write down what you can change, what limits you, and what "better" means, and almost any decision becomes a spreadsheet you can solve.

Unofficially: the name tips its hat to "EPICAC", Kurt Vonnegut's first published short story (Collier's, 1950 — you'll find it in Welcome to the Monkey House), about a room-sized vacuum-tube computer that people bring their hardest math problems. In the story, EPICAC is handed the one problem it can't optimize its way out of — being in love — and handles it with more grace than most of us would. It is the best thing ever written about asking a machine for answers to human questions, it takes fifteen minutes to read, and you should go read it.

This EPICAC is not affiliated with the Vonnegut estate, only does optimization, and has no feelings about your constraints. So it goes.

This tool stands on excellent open source, and credit belongs where it's due:

• HiGHS (MIT) — the high-performance LP/MIP solver from the University of Edinburgh, compiled to WebAssembly via highs-js. It does all Simplex/branch-and-bound work and supplies the duals behind the sensitivity report.
• HyperFormula (GPLv3, Handsontable) — the headless spreadsheet engine that evaluates the grid you see and edit.
• SheetJS (Apache-2.0) — .xlsx/.csv reading and writing, including formula import.
• Recharts (MIT) — the telemetry charts; Dexie (Apache-2.0) — IndexedDB run history; Zustand (MIT) — state management.
• Next.js / React (MIT) — the app framework, and Rust + wasm-bindgen for the engine toolchain.

What's custom-built for this site: the Rust engine crate — an Excel-formula parser and bytecode compiler/evaluator, the Evolutionary engine (real-coded GA with feasibility-lexicographic ranking), and the GRG-style nonlinear engine (augmented Lagrangian with spectral projected gradient descent and multistart) — plus the linear-coefficient extraction that feeds HiGHS, the telemetry/insights pipeline, and the entire workbench UI.

Nowhere but your browser. The sheet lives in memory; run history lives in IndexedDB on your machine. There is no backend, no analytics on your model data, and the site works offline after first load. Clearing site data clears your run history.

EPICAC is built and maintained by Charlie Petch, a developer in Connecticut (CT), as a free, open-source personal project. The full source is on GitHub — issues and pull requests welcome. If EPICAC solved something for you, that's the best possible outcome (see: the name).