This is an extension of @SEJPM's answer. I want to expand on what protocols are best to use (I apologize ahead of time for self citations). First, for details on Yao's protocol, see A Proof of Security of Yao's Protocol for Two-Party Computation. However, to do this very efficiently, you need to have two very efficient components:
A fast garbling scheme: see JustGarble and this alternative. Code for garbling can be found in the open source SCAPI library on Github.
Fast oblivious transfer: when you need to run many, then oblivious transfer extensions should be used. See this paper for the fastest current protocol. (It's implementation can also be found at SCAPI.)
Another alternative is to run the GMW protocol based on oblivious transfer extensions. See GMW vs Yao and here.
The above all relates to semi-honest adversaries. If you want security for malicious adversaries, then you need to work much harder. Here it depends if you want a single execution of multiple executions (where you prepare ahead of time). For a few choices see: here, here and here. The last of these also has code at SCAPI.
This is a very biased list (which I really apologize for) and there are lots of other alternatives out there. However, I've tried to give you things that also have available code and support. You can find citations to lots of other work inside the papers I've pointed to.