Loan Calculator
Change the rates and terms, then look at the provenance behind each field.
Yichus answers questions about programs. Which inputs affect this output? Why did this value come out the way it did? Is it safe to apply this batch of transfers? Every answer is checkable instead of being a guess: a structural fact of the compiled program, a replayed concrete run, or an honest “can’t be sure, because…”. The catch is also the reason it works. Programs have to be written in Bosatsu, a small language where every program terminates and every side effect is declared. That is the research bet. A language this small is what buys the guarantees, and there is no retrofitting them onto the Python or TypeScript you already have. The same compiled form does double duty: it runs the interactive demos on this site, and the code-review fact tools read it.
Why? is per-value provenance: click any output and see exactly how it was derived. What-If re-runs with changed inputs and compares outcomes. New here? Start with the Playground. You can also watch Why? work in the tax calculator, or read the AI code-review story.
Exact, checkable facts about a program: which fields are never read, which inputs never affect an output, what happened when it ran. An AI reviewer's claims then get verified mechanically against those facts.
You write the multi-step mutation flow once, as a factory nobody calls. Every mutation stays plain straight-line code, and a checker proves each one follows the flow. Extract the parts afterward and you get an all-or-nothing batch for free.
On a 47k-line codebase with 26 planted defects, a fact-only AI reviewer found 25 with zero false accusations. A source reader at the same token budget found 23. Given unlimited budget, the reader found all 26, at 1.85× the cost. Full data for every round, including the ones the tools lost.
Declare which account balances must never go negative. The checker then decides which transfers in a batch can be safely admitted, and it hands back a trace explaining every deferral, verified by replaying the real handlers.
Declare state-machine properties in Bosatsu, then watch verdicts flip from inconclusive to violated (with counterexample traces) to holds.
Detect when AI-generated functions fake their outputs, meaning hard-coded results dressed up as computation. The check uses the same provenance and dependence facts as the rest of this site.
Interrogate an existing Bosatsu codebase in your browser: overview, trace, search, guided lessons. (This one answers questions about code. The Playground below is where you write it.)
Write Bosatsu simulation code and compile it entirely in your browser, with no server required. It opens with a working example. Edit that, run it, and click any result to see its Why? provenance.
Open Playground Powered by Scala.jsThe architecture, end to end. Watch a button click become a direct DOM mutation with zero re-renders, and see why the analysis reads that same compiled form.
Open the tax calculator and inspect exactly how each output was derived.
Watch data flow light up as derived values trace back to their sources.
Step through an IO lifecycle and see why effects-as-values makes static analysis possible.
Detect when AI-generated code fakes outputs instead of using real inputs.
Program a move loop, predict future-self collisions, then verify the replay. The rules are pure Bosatsu.
Follow a Yichus-specific walkthrough and jump to Bosatsu docs for language basics.
Export the compiled program's analysis file, .matchless.analysis.json. (Matchless is Bosatsu's compiled form.) You get IO sites, causal edges, and per-binding purity summaries.
Drive a stateful debugging session over compiled Bosatsu from the CLI daemon (yichus's long-running analysis server) and the explorer at once.
Audit CRUD services for permission findings and query diagnostics, derived from the compiled program's typed intermediate representation.
github.com/snoble/yichus holds the docs, the source, the measurement artifacts, and local setup (JVM + sbt).
Change the rates and terms, then look at the provenance behind each field.
Explore brackets and assumptions. Every output can be explained and traced.
Model emissions scenarios and inspect the chain behind each total.
Run a set of portfolio assumptions and compare how the scenarios come out.
Try different strategic allocations and compare how they perform in simulation.
Compare branch outcomes side by side, with the full provenance for each.
The smallest state update there is. The same event always gives the same output.
Operations on list state, where adding and removing take predictable update paths.
Compose a list on the fly and keep the rendering paths stable.
Views that switch on a condition, with every state transition written out.
Controlled inputs that stay in sync with state, with no hidden effects.
Pointer interactions, with the IO event flow spelled out behind them.
Keyboard input that responds fast, and every effect is handled in the open.
A canvas animation loop written entirely as Yichus IO updates.
A lot of animated state changing at once, driven by incremental runtime updates.
See where the IO boundaries sit and when the runtime mutates state.
Recursive rendering patterns that compile down to direct DOM updates.
Follow provenance end to end, across UI bindings and derived values alike.
Early copy-through detection demo, superseded by AI Code Detection above.
Five particles with gravity, bouncing, and damping. 60fps canvas animation in pure Bosatsu.
Items move between zones on desktop and mobile, using O(1) style binding updates.
Direct incremental updates compared against React 18 render loops across three scenarios.
Evaluate the policy branches and see why one path was selected.
Walk the tier transitions and trace every decision point along the way.
Plain rate math, with provenance on every field.
Portfolio metrics you can trace back to how they were derived.
Fold-based compounding, a language-mechanics exercise.
How closure capture behaves, as a language-mechanics exercise.
Step the deterministic rules fixture tick by tick to inspect collisions, rewinds, and win conditions.
Validate the reusable grid renderer, tile palette, and entity drawing primitives that power the game.