System requirements

ARTGTO is a native Windows application. The solver does all its work on your CPU — there is no GPU requirement and no cloud connection during solving.

Summary

CPU: why AVX2 is required

ARTGTO is compiled for the x86-64-v3 instruction level. That means AVX2, FMA, and BMI2 — vector instructions that let the solver process many hands at once. Almost every desktop and laptop CPU made since around 2013 supports this:

• Intel: Core 4th generation ("Haswell", 2013) and newer
• AMD: Ryzen (2017) and newer, plus some late pre-Ryzen chips

On a CPU without AVX2, the application will not run. There is no software fallback, because the solver's speed depends on these instructions.

Cores and threads

More cores help, but not without limits. Two facts shape how ARTGTO uses your CPU:

1. By default, the solver uses all logical threads. On a CPU with hyperthreading / SMT, that is twice the number of physical cores (for example, 16 threads on an 8-core chip). Measured on an 8-core machine, using all 16 logical threads makes solves 20-30% faster than using only the 8 physical cores. The reason: the solver spends much of its time waiting for data from memory, and the second hardware thread on each core fills those waiting gaps with useful work.

1. Speed does not double when cores double. Within a single solve, going from 1 to 2 cores helps a lot, 2 to 4 still helps, but beyond that each extra core adds less. At 8 or more threads, each thread runs at roughly 55-60% efficiency. The bottleneck is memory bandwidth: all cores share the same memory channels, and on big trees those channels saturate.

The Solver cores slider

You can change how many threads the solver uses. Open Settings (gear icon), go to the Performance section, and adjust Solver cores. The slider goes from 1 up to the number of logical threads on your machine. The tooltip summarizes the default: 20-30% faster with all logical threads (includes SMT); default is all cores.

When to lower it:

RAM

The solver holds the whole game tree in memory while it works. How much RAM a solve needs depends on:

• Effective stack depth — deeper stacks allow more raises, which multiplies the tree.
• Number of bet sizes per street — every extra size multiplies branches.
• Range width — every hand in each range needs strategy storage at every decision point.
• Whether the turn/river are fixed — a flop solve covers every runout and is far larger than a single-runout solve.

Tree building explains these factors in detail.

If a spot does not fit in your RAM, you have two tools, both in the solver controls:

• 16-bit compress — stores the solver's working data at half size. Slightly slower per iteration, and on strongly polarized boards accuracy cannot be refined below roughly 0.2% of the pot. At the default 0.3% target this limit does not matter.
• Low-memory fallback — on by default. If a spot cannot fit at all, even with compression, the solver automatically groups similar-strength river hands together to make it fit. Flop and turn keep full per-hand detail and showdowns stay exact; only river decisions lose some precision. Solves that used this are clearly labeled (river-bucketed @ N in the status). It never engages on spots that fit normally.

Disk

Plan disk space for your solution library. Each saved solution is a single .art file; batch exports for the companion viewer use the .artgto (CBOR — companion-app format, single file) format with adjustable compression (a ZSTD Level from 1 to 22 — higher levels make smaller files but take longer to export; viewing speed is unaffected).

Application data, settings, logs, ranges, and bet sizing profiles live under %APPDATA%\artgto\ and take little space.

Next steps

• Quick start — install and run your first solve.
• How the solver works — what the solver does with all those cores.