Algorithms is out now on Steam for Windows and Linux.

It is a native, offline algorithm practice application built around a short loop: read a problem, write a solution in C, run the complete test deck, and inspect the verdict. There are no accounts, subscriptions, or remote judge servers. The compiler, machine, problem bank, and judge all run locally.

The Steam package includes two applications: Algorithms Pro and Algorithms Retro. They present the same 188 problems in two different workbenches, but share the same compiler, virtual machine, judge, solutions, and progress.

Algorithms is available on Steam here.

One product, two workbenches

Algorithms Pro is the modern side. I built its interface with FUI, my retained-mode native UI framework. The application has dockable panels for the problem catalog, statement, C editor, disassembly, and output. Search can filter the bank by text, category, or difficulty. The editor has completion, diagnostics, formatting, find and replace, and the keyboard commands I expect from a desktop code editor.

Algorithms Retro contains the same practice system in an IBM VGA terminal workbench. It can look like a black-and-green terminal, an early Windows machine, or a monochrome workstation. This is not a separate problem set or a simplified edition. It compiles and judges the same source against the same test data.

Both applications open the same solution files and progress record. A problem solved in Pro is solved in Retro. Code written in one opens in the other. Only the presentation settings are separate, since a docked desktop interface and a terminal interface need different configuration.

How a run works

The catalog contains 188 problems across 20 categories. It starts with small exercises and continues through arrays, strings, trees, graphs, dynamic programming, backtracking, parsing, bit operations, scheduling, and systems work. The current bank has 70 Easy, 104 Medium, and 14 Hard problems.

Opening a problem gives the editor a C function stub with the signature the judge will call. Pressing F5 starts one complete run:

1. The built-in C frontend parses the source and emits instructions for the Algorithms virtual machine.
2. The judge creates a fresh machine for each test, copies the input into guest memory, and calls the solution's solve function.
3. Each problem declares whether its answer is a return value, exact console output, or both. The judge compares the result accordingly.
4. The complete deck includes the visible examples and hidden cases. Every test must pass before the run is accepted.

The output panel keeps this concrete. It lists every test, the observed and expected result when they differ, any machine fault, and the instruction count. An accepted run records the number of tests passed, the total instructions executed, and the compiled code size. The solved checkmark in the catalog is simply the result of that complete deck passing.

There is no call to Clang, GCC, or MSVC in this process. The C compiler is part of Algorithms. It reads one source unit and targets the application's own 32-bit instruction set directly. Common include lines are tolerated for pasted solutions, but there is no host header or filesystem behind them.

Deterministic judging

Online judges usually measure elapsed time. That makes a limit depend on the server, current load, and implementation details outside the submitted program. Algorithms uses an instruction budget instead.

Each test gets up to 2,000,000 instructions. The virtual machine has 16 MB of guest memory, sixteen 32-bit registers, a checked 1 MB stack, a separate call stack, and a 64 KB console limit. Loads and stores check their bounds and alignment. Null access, division by zero, stack overflow, invalid frees, and nonterminating programs produce named faults rather than reaching host memory.

The machine has no clock, random source, network access, or host access. Runtime services such as memcpy, memset, allocation, and console output are charged against the same budget as ordinary instructions. The same source and test therefore produce the same verdict and instruction count on Windows or Linux, on a fast machine or a slow one.

The judge advances execution in bounded slices. A long solution can be stopped, the interface remains responsive, and resuming a slice does not change the machine state or final count.

Reading what the compiler produced

The disassembly panel is part of the main workflow rather than a separate developer tool. Every emitted instruction carries its source line and origin. Moving the caret in the C editor highlights the instructions generated for that line, which makes the cost of a loop, comparison, memory access, or function call visible.

Source-only mode hides compiler prologues, epilogues, and runtime wrappers. It leaves the instructions produced by the written C and any inline assembly, so the listing remains readable. The complete listing is still available when the implementation details matter.

The supported C subset is deliberately documented and fixed. It includes integer types, pointers, local arrays, functions, normal control flow, allocation, memory operations, formatted output, and inline assembly. It does not quietly fall back to a host compiler for unsupported features. The compiler reports a specific diagnostic instead.

Keeping the two applications honest

Shipping two interfaces is useful only if they remain the same practice environment. Algorithms Pro owns the compiler, judge, generated problem bank, and shared save contract. The Retro tree carries a byte-identical mirror of those sources. A synchronization check is part of the publication gate, so a compiler fix or catalog change cannot be released on one side alone.

The problem catalog is generated into C++ and checked into the build. This keeps all statements, examples, hidden tests, reference solutions, categories, and difficulty ratings inside the application, with no service to contact after installation.

Solutions are ordinary .c files saved automatically as I type. Progress is a small versioned JSON document. Before writing progress, either application merges the solved set already on disk, which prevents one interface from erasing work recorded by the other. The write path uses staging and replacement rather than truncating the live file first.

Algorithms began as the compiler and judge behind an earlier project. For this release I separated that machinery from the surrounding game, reduced it to one documented C language, built a professional workbench around it, and then gave the same core a second terminal presentation. The result is a local practice environment where the verdict can be inspected all the way down to the instructions that produced it.

Algorithms is available now on Steam.

Back to Home