Changelog

Code that exhausts the sandbox's memory is now reported as an out-of-memory error on the tests it broke, the same way a stack overflow already was. Before, some of these runs came back as a platform error that asked you to try again, were retried several times behind the scenes, and took around 20 seconds per click. They now fail fast and say what happened.

The algorithm catalog got the same duplicate audit as the database track. 19 algorithm puzzles were retired as clones of a kept exemplar (same technique, same rejected naive, same gate), leaving 114. As before, retired puzzles still open from a link and keep your progress. Find the Duplicate Number was reworked so a hash set no longer passes, and four descriptions that spelled out their own solution now name the trap instead.

The four smallest tracks each gained six katas. Architecture: the clock as a dependency, caching as an adapter, recorded events, edge versioning, plugins, and modules. Design Principles: identifier types, illegal states, single responsibility, speculative layers, undo, and visitors. Test Writing: stateful subjects and their collaborators. Secure Coding: ReDoS, alternate IPv4 spellings, Unicode lookalike usernames, card-number redaction, shell quoting, and snippet expansion bombs. The catalog now holds 504 puzzles, plus 64 System Design challenges.

Every code track gained five challenges, one Easy, two Medium, and two Hard: Algorithms, SQL, Database / EF, Architecture, Design Principles, Refactoring, Secure Coding, and Test Writing. Topics include call-auction clearing, bounded range-sum counting, saga compensation failures, escaped stream frames, HTTP framing, and fenced leases. Each one ships with a starter, progressive hints, a reference solution, and hidden grading fixtures.

Together with 15 challenges added at the end of August, three each in Algorithms, Architecture, Design Principles, Secure Coding, and Test Writing, the catalog stands at 499 puzzles, plus 64 System Design challenges.

System Design Foundations is the first learning path for the Studio: about six hours across four sections and 12 challenges from the Fundamentals and video platform series, with progress, resume, and a completion badge like every other path. It is a Pro path; the six free Studio challenges stay free.

A new five-stage course, Build a Verifiable Release Pipeline (one Easy, two Medium, two Hard), has you separate trusted build evidence from untrusted build execution, sign with a build identity, verify before promoting a release, verify inside a disconnected release zone, and require independent checkpoint witnesses. The Studio now has 64 challenges.

The dashboard now opens with your next practice session: the unsolved puzzle you last worked on, otherwise the next step of the free Katabench Tour, otherwise a fresh Easy puzzle, and always one your plan can open. After a clean pass, the results panel also suggests one free puzzle from a track you have not tried yet, and finishing a paid track's free sample points to where Pro continues.

Choosing a plan and billing period on the pricing page now carries through sign-up, email verification, and checkout, so you finish on the plan you picked.

A solver pointed out that many SQL puzzles were copies of one another, including Hard puzzles solved by deleting a single lower() call. Two audits agreed, so 80 near-duplicates were retired: 72 database puzzles and 8 refactoring ones. Retired puzzles leave the catalog list but still open from a link, and your progress on them stays.

In their place come 138 new puzzles written from scratch: anti-joins and NULL semantics, window frames, recursive CTEs, gaps and islands, set operations, time zones and DST, JSON, full-text search, and the edges of EF Core's query translation, among others. The surviving puzzles were rewritten so descriptions and starter comments stop handing over the fix, and difficulty labels now follow the size of the change you have to make. The track holds 196 puzzles: 106 SQL and 90 EF Core, 71 of them Hard. The Database track guide covers how they are graded.

Reopening a puzzle you have solved now shows your accepted solution instead of the starter, on any device. This applies to solves from this release on; before it, only a fingerprint of accepted code was kept. The learning tip of a solved algorithm puzzle and the lesson of a solved System Design challenge also stay available without submitting again.

The playground and the Studio now sit inside the app's navigation, so one rail with Playground, System Design Studio, and Learning paths is on every page. It collapses at any screen size and remembers your choice.

A ten-stage Distributed Web Crawler course takes the Studio past request-response designs: a durable URL frontier, checkpointed stages, URL and content deduplication, polite per-host scheduling, partitioned ownership, recrawls for freshness, and indexing. The Studio now has 59 challenges. The URL shortener and video platform courses were reworked so their final designs no longer repeat the Fundamentals patterns under new names.

The Inspector now explains the selected component: what it does, what it may connect to and receive connections from, and which way the arrow points where that is easy to get wrong (a queue points at its workers, because arrows show which way messages travel). An All puzzles button takes you back to the code playground.

The System Design Studio is open in beta. You place provider-neutral components on a canvas, connect them, and the grader checks the topology against the challenge's rules. It launches with 49 challenges: a Fundamentals series, seven product builds (video platform, URL shortener, file vault, notification platform, real-time chat, reliable checkout, social feed), and an optional capstone.

Check grades your design against the public traffic scenario; Submit adds hidden ones and records the solve. Once every structural rule holds, a capacity report models p99 latency, throughput, error rate, and monthly cost, and names the bottleneck. A passing Submit unlocks a lesson on why the design works. Six challenges are free; Pro opens the rest. See the overview and the Studio guide.

Signed in, your in-progress code is saved to your account as you type and restored on any device, for single-file and multi-file puzzles. Drafts already in your browser move to your account the first time you sign in, and the local copy stays until the server confirms the save.

The editor also runs a C# language service in your browser: completion that adds the using for you, signature help, hover information, and live diagnostics across every file in the puzzle. It runs in a web worker, so typing never waits on a server, and if it cannot start, the editor falls back to its built-in completion.

The "Why this works" explainers now cover the whole algorithm catalog: all 125 algorithm puzzles have an authored learning tip. After a passing submission the tip opens in the problem pane, so your results stay visible beside it; on a phone it appears as its own Learn tab. As before, a tip unlocks only after you solve the puzzle, so it can never spoil one.

Signed-in accounts have a notifications bell in the header, with an unread dot and a short list of announcements. Major launches also show a one-time banner that you can dismiss. Read state is stored with your account rather than in the browser, so something you already saw on your laptop does not show up as unread on your phone.

A contribution graph shows one square per day for the last year, shaded by how many submissions or runs you made, with your active days and longest streak.

Leaderboard periods now mean what they say: This week counts XP since Monday and This month since the 1st (both UTC), while Last 7 days and Last 30 days keep the rolling windows. Daily streaks now follow your own time zone, taken from your browser, so a late-evening solve counts for the day you actually solved it, and solving on consecutive days where you live keeps the streak going. The contribution graph uses the same calendar.

Architecture katas used to grade only the shape of the dependency graph, which an interface with the right name and one deleted using could satisfy. Now, on Submit, the grader also swaps a fake in behind the port and checks that your code really routes work through it. A design that only looks decoupled fails, with a message that says so. The twelve katas about substitutability carry this check; the ones that grade placement or dependency direction keep their structural rules.

Twelve new katas landed the week before: six architecture katas from Easy to Hard, and six design principle katas on the Law of Demeter, dependency inversion, interface segregation, the service locator, composition over inheritance, and decorators. Architecture now has 19 katas and Design Principles 14.

The app now shares one sidebar across its pages, which becomes a slide-over drawer on phones. The dashboard became an overview, and its long sections moved to their own pages: Activity, Achievements, Leaderboard, and Rewards.

On a phone, the playground keeps Run and Submit in a fixed action bar, shows result status on its tabs, and uses larger touch targets. From the keyboard, every focused control shows a visible outline, the Problem / Code / Results tabs and the file tabs move with the arrow keys, and the divider between editor and results can be resized from the keyboard. First-time visitors get a guided first solve: the tour opens Two Sum and walks through a real Run and Submit.

A gate that lets the brute force through teaches nothing, so all 110 timed algorithm gates now ship with an authored naive solution, the obvious approach the description warns about, and the test suite proves each hidden gate rejects it. The sweep found gates that accepted their own naive, including one where a vectorized built-in search let an O(n²) scan pass; budgets were tightened and fixtures reshaped until every gate held. Two puzzles whose visible cases let a wrong algorithm pass got cases that break the coincidence.

The 130 database puzzles got the same treatment: each hidden gate passes the reference and rejects both the shipped starter and the most plausible wrong approach. Submitted code also runs with a 16 MB stack, so textbook recursion, like a recursive flood fill, is graded instead of crashing.

The Tests tab now opens with a scorecard that shows a submission's verdict at a glance, with dimensions that fit the puzzle kind: correctness, time and allocation budgets, attack payloads for secure coding, query-plan rules for database puzzles, structure rules for architecture, design, and refactoring, and mutants caught for test writing. Your best-time standing sits alongside it, and the full test grid is still right below.

Run got more useful too: the Output tab shows expected next to actual for every sample case, with the mismatch highlighted, so you no longer spend a submission just to see what a case wanted.

Learning paths turn the catalog into ordered courses. Each path has sections, stated outcomes, an estimated time, and a progress view that resumes at your next unsolved exercise. While you work through one, the playground keeps the path's context and Next puzzle follows the path order. Finishing a path awards a permanent course badge.

The Katabench Tour is free. Five Pro paths go deep on one discipline each: Algorithm Patterns in C#, High-Performance Data Access, Refactoring Legacy C#, Secure Web APIs in C#, and Architecture Boundaries. The learning paths guide explains how progress is counted.

The Database track now covers both ways .NET code talks to a database. SQL puzzles have you write real PostgreSQL and run it through Dapper; Database / EF puzzles stay in LINQ. Both use the same grader and the same throwaway PostgreSQL instance, and the sidebar lists them as separate sections: 45 SQL and 85 EF Core puzzles.

An advanced tier of 25 plan-graded index puzzles goes past single-column lookups: composite indexes and their leftmost prefix, one index serving a filter and an order with no sort step, two indexes combined with BitmapAnd and BitmapOr, and joins through a foreign-key index. Every database puzzle also shows a schema viewer under the description: each table's columns, primary and foreign keys, and a few sample rows.

The rewards shop could be bought out after about two weeks of casual play, so it was repriced to last months: titles now cost 100 to 2,000 gems and the Midnight and Forest editor themes 750 gems each. Streak freezes keep their prices.

Solving a puzzle after revealing its solution now pays like practice: the re-solve XP rate and 1 gem, with no first-solve bonus, no daily challenge completion, and no progress toward the first-try or optimal achievements. It still marks the puzzle solved and keeps your streak alive. Revealing after an honest solve changes nothing, and re-solving a puzzle pays the practice rate once per puzzle per day.

The app now has a light theme. A switch in the header flips it; dark stays the default, and your choice is remembered and applied before the page first paints, so there is no flash of the wrong theme on load. The code editor gets its own light color scheme, and puzzle descriptions, hints, and code blocks follow the theme you pick.

Pro and Pro+ can now be bought from inside the app. Checkout runs on Paddle, our merchant of record, which handles payment, tax, and receipts. Pro is $19 a month or $180 a year, Pro+ is $39 a month or $370 a year, and Free stays free rather than a trial. Paid subscribers get Manage billing on the Account page, which opens the customer portal to update a payment method, view invoices, or cancel.

The app has its own public pricing page, rendered from the same plan data the checkout charges, so the price on the page is the price you pay. Signed-in Free accounts also see how many graded submissions they have left today, and a warning appears once a daily cap is 75% used, before anything blocks.

We tuned the fairness caps so the free tier stays generous while keeping the platform abuse resistant. Signed-in Free now gets 10 graded submissions a day, a generous 50 runs a day to iterate with, and 3 solution reveals a day. Pro and Pro+ lift the submission, run, and reveal caps entirely (fair use), and Pro+ keeps 4 parallel runs as its differentiator. Every limit now comes from a single source of truth, so the reveal cap is per-plan data rather than a hardcoded free-or-not check.

Hitting a wall is now a clearer moment too: opening a track above your tier shows a proper upgrade panel, the track name, what Pro unlocks, and a direct path to pricing, instead of a flat error.

The moment after a clean pass is the one where you're most ready to learn, and the app used to stop at "You passed." Now a collapsible "Why this works" panel appears, an authored explanation of the optimal approach written against the puzzle's real intended solution. It loads only after you solve, so it can never be peeked before you've earned it, the same care we take with hints and the reference. The toggle remembers whether you keep it open. The first explainers are live, with more landing across the catalog.

Passing was the bar, but fast was invisible, so now it isn't. A clean signed-in pass now shows "Faster than X% of solvers" in the results panel, ranked on your persisted best time for that puzzle so it stays stable across re-submits. Each puzzle also has its own top-25 fastest board. Reveals don't count toward the ranking, the leaderboard is for solutions you actually wrote, and the percentile is computed the moment you pass.

The catalog now holds 374 graded puzzles across seven disciplines, each with its own grading engine:

🧹 Refactoring (54 puzzles): inherit working-but-awful code, including the famous Gilded Rose, and clean it up. The tests must stay green while structural gates measured from your source (method length, cyclomatic complexity, nesting depth, duplicate blocks) force the mess out.

🛡️ Secure Coding (20 puzzles): fix functionally-correct-but-exploitable code against real attack payloads, path traversal, SQL injection, SSRF, log forging, open redirect. Two suites grade every submission: exploits blocked and behavior preserved.

💡 Design Principles (8 puzzles): small katas on immutability, sealing an aggregate's invariants, and dependency inversion, graded on structure the way the architecture track is.

✍️ Test Writing (24 puzzles): you write the suite, and it passes only when it catches enough planted-bug mutants, coverage that has to actually detect regressions.

The founding tracks anchor the rest: 125 algorithm puzzles with performance gates and allocation budgets, 13 architecture katas, and 130 database puzzles, including the plan-graded ones where the execution plan itself is pass/fail.

Database puzzles now grade how the database executed your query, not just what it returned. Submit a LINQ solution and the results panel shows what the database actually did, and puzzles can grade that execution. Getting the right rows the wrong way is now a visible, gradeable mistake.

Time wasn't the whole story, so now it isn't the whole grade: every test reports bytes allocated on the managed heap, and puzzles can set an allocation budget alongside the time budget. The results panel got a memory-budget bar to match, fast but wasteful no longer passes quietly.

The whole front end was rebuilt in React, same dark, keyboard-friendly workspace, now fully responsive down to mobile with a slide-over puzzle drawer and Problem / Code / Results tabs. Monaco (the editor inside VS Code) is bundled locally, your in-progress code and solved puzzles carry over, and everything renders noticeably faster.