This is great.

Since you've asked about bugs, I tried pushing the limits and found the following:

    A1: 100          B1: =100-A1
    A2: =A1*(100-A1)
    A3: =A1*B1

A2 can be successfully set to anything reasonable (up to 2500)

However, setting A3 to exactly 100 doesn't work, even though setting it to 101 or 99 (or even 100.000001) does work.

Another limit:

    A1: 100          B1: 100
    A2: =A1+B1
    A3: =A1*B1
    A4: =abs(A2-100) + abs(A3-100)

Setting A4 to zero (or anything below 80) doesn't work. This doesn't improve if the constants in the A4 formula are moved a short distance away from 100.

In case you can't tell from that last example, I think being able to fix the intended values of multiple outputs simultaneously would be interesting. If you were to give more details about the solver's internals, I'd be keen to hear them.

I think the concept is solid. I’ve only had a few minutes of playing with it, but I have the opinion is that from a UX perspective constants are more common than variables. So perhaps a cell containing a constant should not have a #, but a variable should.

This is really cool! It's like Excel's goal seek but can also handle the case of arbitrary input cells. Goal seeek can only handle one input and one output cell.

But how do you handle the case where multiple variables can be changed? If multiple input cells is the key difference from Goal seek, i think some more rigor should be placed into the algorithm here

e.g. setting A1 + B1 and wanting the result to be 5. Currently it bumps both A1 and B1 equally. What's the thought process behind this?

Wow! See the classic https://en.wikipedia.org/wiki/TK_Solver

A bidirectional formula is also known as an integrity constraint in databases (plus some triggers for restoring the constraint upon updates)!

The idea is very interesting. As a default strategy you could preserve the ratio of inputs by scaling them to match the scaling of the output, instead of making them equal (for addition). Similarly, for multiplication, you could preserve the ratio of inputs as well, by scaling them by nth root of the scaling factor of the output.

The examples are great and these bidirectional calculators are something that people would love to have in traditional spreadsheets.

So much so that Credit Suisse, which basically was running everything on heavily modded Excel, created a full language whose outputs were Excel spreadsheets capable of doing that. That thing called “paradise” was a total monstrosity but showed how much people wanted this.

That said, you really need a way to set which cells are fixed and which cells are allowed to move if you want to move past basic examples.

Most times you know what you want to do. like => if the user modifies that cell, find a solution for those specific ones.

If you can enter that info, then you have a lot more constrains for your solver and will avoid a lot of edge cases where everything goes to 0, and you can check that the calculation entered is indeed reversible or not, or if it could have multiple solutions, and so on.

Could you build an inverse kinematics solver with this? (I recently watched a youtube video of someone iteratively working out the solutions for a robotic arm, by alternating modifying the inputs and the results)

Phenomenal! This is a solid prototype, clean execution. I've had exactly this idea, too: I've already given the spreadsheet the relationships between these values, why can't it just work backwards when values change? That premise hides a ton of complexity, though, I'm sure. Lots of scary matrices.

Sympy can (often) solve under constrained systems in terms of the free variables. The problem I run into is discrete constraints that make solving less closed form and more combinatorial search. When textbook amplifier formulas significantly diverge from physical reality I model the errors as linear correction factors and use gradient descent to correct it in a few experiments, but I’m curious if there is software that has solved this problem.