TexasSolver: a C++ GTO solver for Texas Hold'em and short deck

What TexasSolver actually solves, and for whom

TexasSolver computes game-theory-optimal strategies for postflop spots in Texas Hold'em and short deck. You give it a board, ranges for each player, a bet-size tree, and stack depth; it returns a mixed strategy for every decision node. That is the same job PioSolver does, and the README states the results are aligned with PioSolver on the benchmark it publishes.

The intended user is a poker player or researcher who wants solver output without paying for a commercial licence. The README answers the licence question directly: for personal users the solver is open sourced and free. It is not aimed at someone who wants a hosted web tool or a mobile app. There is no server component in the repository layout, and the top-level entries are Qt UI files, C++ sources, and a benchmark directory.

The project is a C++ rewrite of TexasHoldemSolverJava. The README claims it is 5x faster than the Java version and uses less than one third of the memory. That claim comes from the project, not from an independent measurement, and the benchmark table below is the only performance data in the README.

How the solver is put together

The repository splits into two front ends over one C++ core. The GUI is built with Qt 5.1.0 (open source edition), per the FAQ, and the console version is built with Mingw and CMake. On disk you can see that split: mainwindow.cpp, boardselector.cpp, rangeselector.cpp, settingeditor.cpp and strategyexplorer.cpp are the GUI side, each with a matching .ui file, while src/ and include/ hold the solver itself. main.cpp is the entry point for the GUI binary.

The data flow is visible in the file names. A board selector picks the community cards, a range selector builds each player's range, and a setting editor holds the tree parameters. The solver consumes those and the strategy explorer reads the result back. The README lists two output-related features: cross language calls, and dumping the strategy to a JSON file. The JSON dump is what makes the result usable outside the GUI, since it gives you the per-node strategy in a format other tools can read.

Translation files (lang_cn.qm, lang_en.qm and their .ts sources) sit at the top level, so the GUI ships with English and Chinese strings. The benchmark directory holds the PioSolver comparison configs and logs referenced in the README, which is the only place in the repository where measured convergence times appear.

Installing TexasSolver and running a first solve

The README is unusually short on installation. It says to download the package for your OS from the release package page, unzip it, and that installation is done. There is no build-from-source instruction in the README, and no package manager entry, so the release archive is the intended path. The latest release listed is v0.2.0 from 2021-11-04.

After unzipping, the GUI binary is what you launch. On Windows that is TexasSolverGui.exe; on macOS it is TexasSolverGui.app.

# after downloading and unzipping the release package for your OS
# Windows
TexasSolverGui.exe
# macOS
open TexasSolverGui.app

The README does not document command-line flags for the GUI binary, so there is nothing to pass here. If you want the console build, the README defers to a separate console branch document rather than repeating the usage in the main README.

Inside the GUI, the first real task is a flop solve. You select the board in the board selector, set each player's range in the range selector, and configure the tree in the setting editor. The README's benchmark configuration is a concrete starting point if you want to reproduce something close to the published numbers: spr=10, a flop game, and a tree of 1 to 2 bets plus all-in. The README notes that in a tree with 1 to 2 bets plus all-in, the speed exceeds PioSolver on the flop. Note that the published benchmark used the console version, not the GUI.

When the solve converges, the strategy explorer shows the result. To get the data out, use the JSON dump feature the README lists. The README does not document the JSON schema, so treat the first dump as something to inspect rather than something to write a parser against.

The published benchmark, and what it does not cover

The README includes one benchmark table comparing PioSolver 1.0 and TexasSolver 0.1.0 under identical settings: spr=10, flop game, 6 threads. PioSolver converged in 242s using 492Mb with an accuracy of 0.29%. TexasSolver converged in 172s using 1600Mb with an accuracy of 0.275%. The README states the results are very close and links a comparison image.

Read that table carefully before treating it as a general speed claim. TexasSolver used roughly three times the memory to finish faster. On a machine with limited RAM, the 1600Mb figure is the number that decides whether the solve runs at all, and the memory advantage the README claims over the Java version does not translate into a memory advantage over PioSolver. The table also covers exactly one configuration. There is no data for turn or river solves, for deeper trees, or for short deck, even though short deck is a supported game.

The version in the table is 0.1.0. The current release is 0.2.0, and the README does not republish the benchmark against it. So the headline comparison is a snapshot of an older build.

Where TexasSolver is the wrong tool

The README opens with a warning that the project still works but a much faster GPU version, TexasSolverGPU, is available at a linked page. That is the project's own advice, placed above the title. If you are starting fresh and have a suitable GPU, the maintainer is steering you elsewhere. Choosing this repository means choosing the older CPU path deliberately.

The second limit is licensing, and it is a hard boundary rather than a preference. The project is AGPL-3.0. The FAQ states that if you integrate the release package binary into your software, you can do that; but if you want to integrate the solver code into your software, or provide a service through the internet, you need to contact the author for a commercial licence. The FAQ also states you may not upload the binary to other sites or share it with friends, only link to the project. Anyone planning a hosted solver feature should treat this repository as unavailable without a commercial agreement.

Third, there is no mobile or real-time path here. The repository is a desktop Qt application plus a console binary. Nothing in the layout suggests a mobile client, and the README does not mention one.

Finally, the documentation is thin in places that matter for automation. The README mentions cross language calls and JSON dumping but does not document either interface. If your workflow depends on driving the solver from another language, you will be reading src/ and include/ rather than the README.

TexasSolver against PioSolver and the Java solver

The obvious alternative is PioSolver, and the difference is not mostly about speed. PioSolver is commercial, and the README's own benchmark shows it converging in 242s against TexasSolver's 172s while using less memory. What TexasSolver offers instead is source access under AGPL-3.0 and a zero price for personal use. If you need to read or modify the solver, or you object to a per-seat licence, that is the whole argument. If you need low memory usage on a modest machine, the benchmark table argues the other way.

The closer comparison is TexasHoldemSolverJava, the project TexasSolver was rewritten from. The README states the C++ version is 5x faster and takes less than one third of the memory. That is a same-author comparison and it is the strongest case for picking this repository over its predecessor. If you already run the Java solver, the migration is a rewrite of your tooling around a different binary, not a config change.

GTO+ and GTO Wizard appear in what people search for around this project, but the README does not discuss either, so there is no basis here for a feature comparison. The same goes for the Rust and WASM solvers in those search terms: the repository says nothing about them.

Maintenance, licence and upgrade cost

The last push to the default branch was on 2026-08-26, so the repository is not abandoned. The release history tells a different story: v0.1.0 in 2021-08-17, v0.1.1 in 2021-09-08, and v0.2.0 in 2021-11-04. There has been no tagged release since 2021-11-04, and the README's benchmark still reports version 0.1.0. Code activity and tagged releases have diverged, which matters if you pin to release archives rather than building from master.

Upgrade cost is low in one sense and unknown in another. The install path is unzip-and-run, so moving between releases is a file swap. But the README does not document a version compatibility policy, and it does not document the JSON schema, so an upgrade that changes the dump format would not be announced anywhere in the README. If you build a pipeline on the JSON output, that is the risk to plan around.

On licensing, the AGPL-3.0 terms and the FAQ's commercial-licence requirement for code integration and internet services are stated by the project. The repository also carries a licensed_list.txt naming licensed users. None of this is legal advice; if you intend to ship anything built on the solver, read the LICENSE file and the FAQ together and take your own advice.

Editorial conclusion

Adopt TexasSolver if you want a free postflop solver for personal study and you are comfortable building a tree by hand in the GUI. Do not adopt it if you need a hosted service, a mobile client, or a solver you can embed in a product without a commercial licence. Before you commit, check the release page for a package matching your OS, and confirm whether the GPU version at the linked page covers your hardware, since the README now points there first.

Frequently asked questions

Official sources

1. bupticybee/TexasSolver on GitHub
2. License: AGPL-3.0
3. Project website
4. README
5. Releases