Own product · app · 2026

A Sudoku that feels at home on every system.

A free game with no ads, accounts or server. On the iPhone it looks like an Apple app, on a Pixel like Material 3 Expressive, on Windows like Fluent and on Linux like GNOME. The board inside is one: its own code draws it and each system dresses it in its own tokens.

Get it

Coming soon

The packages are ready; the App Store and Mac App Store are waiting for the Apple Developer account, Google Play is finishing its tests.

AppGallery badge: Serkan Aydin, Wikimedia Commons, licensed CC BY 4.0.

The app’s interface is Polish only — the boards and the screenshots below show it as it ships.

A real medium puzzle from the app’s bank, solved step by step by its engine, the way a person would.
  • 11platform families: from the iPhone to the TV
  • 6native look kits
  • 50techniques in the hints
  • 0ads, accounts and servers

Chapter 1: Principles

The puzzle should be calm. Everything else serves it.

Six decisions made at the start and never reopened. Each one closes a shortcut.

  1. Free, for real

    No ads, payments, accounts or backend. The app collects no data, so there is nothing to switch off in the privacy settings.

  2. No server, yet shared

    The daily puzzles are the same worldwide, though no server sends them out: every device picks them itself from a frozen bank.

  3. Native, not “the same everywhere”

    Six look kits instead of one shared one. Controls, motion, haptics and sound come from the system the game runs on.

  4. Four sizes, six levels

    4×4 to warm up, 6×6 for a break, the classic 9×9 and 16×16 with the letters A–G. Difficulty comes from the techniques a solve needs, not from the number of givens.

  5. Polish, and neutral

    The whole interface is Polish only: 1,045 strings with proper plural forms and no gendered wording (“Gotowe!”, “Done!”, never “you finished” in a gendered form).

  6. An engine written from scratch

    The solver, generator, rating and 50 techniques in plain Dart, with no dependencies. Clean-room: no code or tables from HoDoKu, QQWing or SukakuExplainer.

Chapter 2: Six systems

One board, six ways to look at home.

The board is no system’s control: its own code draws it. Each kit hands it tokens: colours, line widths, the selection’s radius, digit weights and motion timings. Switch the kit and see what changes and what stays.

4
7
3
8
2
5
5
7
6
2
3
8
3
8
2
6
7
5
8
3
2
7
1
8
3
7
1
9
2
5
6
4
1
4
6
7
9
8
3
2
3
8
6
5
9
4
8
3
5
2
8
3

The system accent, under guard

You pick an accent colour in the system settings and the board takes it, but only for the selection, the peers and the same digit. BoardAccentGuard checks every combination: text keeps at least 4.5:1, marks 3:1, and the hue stays clear of the error red. When that cannot be done, the board takes grey. The colours below were computed by the app’s code.

Android: an interface in the wallpaper’s colour

Since Android 12 the system draws the Material You palettes from the wallpaper and hands them to the app. They grow the whole Material 3 colour scheme: background, keys, progress bar, buttons and navigation. The board takes the player’s digits from the primary tone and the selection and peers from its hue. When that hue sits too close to the error red, it reaches for the tertiary or secondary palette, and when those don’t fit either, it takes grey. With no system colour the app grows from its own seed. The screens below were rendered by the app itself, with its own code, for six wallpapers.

Seed from the wallpaper#4f5bd5

The Sudoku game screen on Android in Material 3 Expressive, wallpaper: No system colour, Light theme. Background, keys, progress bar, player’s digits and selection in the wallpaper’s colours.

What took the colour

  • Background#fbf8ff
  • Keys#e1e0f9
  • Accent and progress#545a92
  • Player’s digits#262b61
  • Selection#afb3e3
  • Peers#dadbe7

Board: the primary palette’s hue.

Chapter 3: Play

Every move has its motion, its sound and its tap.

The 6×6 board below is a real puzzle from the app’s bank. Play, and the panel beside it shows what a phone would do right now: which haptic iOS fires, which Android does, which sound plays and what the reduced-motion variant looks like.

5
3
1
3
2
4
1
2
4
4
3
6
6
4

Hold a digit for 350 ms to lock it.

What a phone would do

Pick a cell and enter a digit.

  • One impulse per step: negative events before positive ones, and several completions at once merge into one stronger one.
  • At most one haptic per 50 ms: a weaker one in that window drops and its sound plays alone.
  • Replay, sync and restore take the silent path, with no feedback at all.
  • Motion, haptics and sound each have three levels: full, reduced and off. Every moment has a reduced variant.

Chapter 4: Hints

A hint that teaches instead of solving.

Three levels, each saying a little more: first where to look, then which technique, finally what follows from it. The board below shows the engine’s real hint for a hard puzzle, at the moment simple techniques stop helping.

  1. Where to lookThe board dims outside the place where the move is. Sometimes that is enough.
  2. Which techniqueA sheet with the technique’s name and its rule in one sentence. The pattern appears on the board.
  3. What followsThe “ghost pen” makes the move and removes the candidates. The step enters the history like any other.

X-Wing

When a digit fits two rows only in the same two columns, remove it from the rest of those columns (and the other way round).

The nine in rows 2 and 9 fits only columns 2 and 7. However it is placed, it takes both those lines — so 5 candidates 9 leave the other cells of columns 2 and 7.

Level 0 of 3

A ladder of 50 techniques

The engine always reaches for the simplest technique that achieves something: from Full House (1.0) to digit forcing chains (8.8). The same ladder rates the puzzles. The level comes from the hardest step needed, not from the number of givens.

T1Singles, intersections and subsets
T2Fish and single-digit patterns
T3Wings and colouring
T4Uniqueness
T5Chains and loops
T6ALS and forcing chains

Step difficulty (a scale like Sudoku Explainer’s, our own values)

X-WingT2 · 3.7

When a digit fits two rows only in the same two columns, remove it from the rest of those columns (and the other way round).

this technique is in the hint above

Learn

Every technique has its lesson: the rule, how to look for it and examples on mini boards. Learning progress stays on the device.

Chapter 5: Daily puzzle

The same puzzle worldwide. With no server.

Three puzzles a day, Quick 6×6 and Classic and Expert 9×9, harder with every day of the week. Nobody sends them out: every device computes them itself from the date and a frozen file inside the app.

  1. DateThe player’s local calendar day.
  2. FNV-1aThe text “v1|date|tier” becomes a 32-bit number.
  3. Pool indexThe remainder by the pool’s size points to a puzzle in daily_v1.bin.
  4. Sfc32Our own generator, seeded by a second hash, permutes digits, rows and columns.
  5. The same gridEvery device arrives at the same grid, bit for bit.

Day

  • Quick6×6 · Medium

    46131421534145
    key
    v1|2026-11-19|quick
    FNV-1a
    0xFE53D263
    pool: 1200 · puzzle #211
    4266906211 mod 1200 = 211
    Sfc32 seed
    4173149746
  • Classic9×9 · Medium

    937174221665298741346476874
    key
    v1|2026-11-19|classic
    FNV-1a
    0x875B8EBC
    pool: 800 · puzzle #476
    2270924476 mod 800 = 476
    Sfc32 seed
    228028977
  • Expert9×9 · Master

    9745818324239515738691213445
    key
    v1|2026-11-19|expert
    FNV-1a
    0xFBC00AF4
    pool: 1200 · puzzle #532
    4223666932 mod 1200 = 532
    Sfc32 seed
    1733983231

Dart VMdart2jsdart2wasm= #211 · #476 · #532

Three compilers, one result

JavaScript does bitwise maths differently from native Dart. So the engine uses its own helpers (32-bit multiply, shifts, negation) and its own Sfc32 instead of Random, and golden tests compare the results on all three.

daily_v1.bin is frozen. Changing the daily algorithm means a new version and a new file, never rebuilding the old one: yesterday’s puzzle must stay yesterday’s.

A streak that forgives

Every 7 days in a row earn a freeze, two at most. A missed day uses a freeze instead of breaking the streak. No penalties and no pushy notifications.

  • solved
  • freeze used
  • freeze earned

Chapter 6: Engine

Fast where it counts. Stepped everywhere.

Plain Dart with no dependencies: the solver, the generator, the rating, 50 techniques and the hints. Every long operation is stepped: it gets a time budget, gives the frame back and can be cancelled. The interface never waits for anything.

  • 52,443puzzles a second with 17 givens
  • 70 µsa full 9×9 grid
  • 396 µsa full 16×16 grid
  • 2.6–10×faster than the DLX oracle
  • 34,900puzzles in the bank: 1.80 of 2 MiB
  • 2 msrating a 9×9 puzzle

The frame budget

A hard hint (T6, ALS-XY-Wing) takes 34–67 ms in the browser’s worker. Cut into slices by stepFor it never stops the animation: the longest frame is at most 20 ms. Beside it, the same work in one block.

In one blockdropped frames: 3

hint ready

Stepped (stepFor)dropped frames: 0

hint ready

A diagram: 16.7 ms frames, 60 ms of hint work (the top of the measured range).

The heavy tail of 16×16

Checking whether a pasted 16×16 board has one solution can take 10⁶–2·10⁷ steps. So it never blocks: it counts with a step limit and, past it, honestly answers “unknown”. Cancelling such an import takes 3–9 ms.

A soundness oracle

No technique may remove a solution digit or place a wrong one. Tests check this for each of the 50 techniques on 4×4, 6×6, 9×9 and 16×16 boards, and the rating stops with an error rather than store a path that doesn’t end in the solution.

Chapter 7: Flutter

One Dart codebase. Eleven platforms.

The engine, the board, the game, six kits and the statistics are one codebase: Flutter 3.50.0 and Dart 3.14.0. Native code is written only where the system lets nobody else in: widgets, tiles, shortcuts and Siri. On every platform the shared Dart is 95.4% to 99.9% of the code.

The way to the screen

Pick a platform. The column has nine layers, from the engine to the store. The digits in ink are shared code that takes the same path everywhere. The blue ones are filled in by the platform.

  • shared, the same path
  • the platform’s own path
  1. Enginesudoku_enginePlain Dart, no dependencies; the same result on the VM, in dart2js and in dart2wasm (shared, the same path)
  2. Boardsudoku_boardDrawn by its own code, no kit widgets; a completed house’s sweep is a shader (shared, the same path)
  3. Game and screensapp/libRiverpod and go_router; the screens know only the sudoku_design facade (shared, the same path)
  4. Haptics and soundsudoku_feedback42 moments from one matrix, each with a Reduce Motion variant (shared, the same path)
  5. Datasudoku_dataSQLite through drift (shared, the same path)
  6. Kitsudoku_designLiquid Glass from iOS 26, Cupertino before (the platform’s own path)
  7. Bridge to the systemsudoku_platformPigeon → Swift: 7 interfaces (the platform’s own path)
  8. Compilationflutter buildAOT to machine code (shared, the same path)
  9. Package and storerelease.ymlIPA → App Store; waiting for the Apple Developer account (the platform’s own path)

Languages in the repository

This is how GitHub counts: the bytes of every file in the repository, with the tests, the tools and the native code of every platform at once. That’s why there is less Dart here than on any one platform above.

  • Dart88.7%

    The whole app and its tests: the engine, the board, six kits, the game, data, sound and haptics. Plus the tools that keep the rules and generate the native strings.

  • Kotlin2.7%

    Android: the bridge to the system (haptics, the Play store, Google Play Games, Cast, shortcuts), the daily puzzle, continue and streak widgets, the Quick Settings tile and XR headsets.

  • C++2.4%

    Windows: the Microsoft Store (rating and updates), game services and the system accent, plus the window’s runner. Linux: the GTK window controls and the runner.

  • JavaScript1.8%

    Mostly tools: Playwright scripts that take the store screenshots, the videos and the accessibility tests. In the app itself: the service worker, the PWA and Cast in the browser.

  • Swift1.7%

    iPhone, iPad and Mac: the bridge to the system (haptics, StoreKit, Game Center, Cast, shortcuts), WidgetKit widgets, the gamepad buttons on Apple TV and the SudokuCore package with its own tests.

  • Python1.0%

    Tools only: uploading the packages to Google Play, Amazon, Galaxy Store, AppGallery and the Snap Store, the app icons, and AI-agent tools that save tokens.

  • Other1.7%

    Shell (the gate.sh gate and scripts for the Mac, Android, Linux and Xcode Cloud), Ruby (Xcode targets, the Apple TV Podfile), CMake (the Windows and Linux builds), the web version’s HTML, a GLSL shader and Windows resources.

Data: GitHub (Linguist), 19 Nov 2026.

  • 3.50.0Flutter: always the newest stable that passes the full gate
  • 3.14.0Dart
  • 7Dart packages with hard boundaries
  • 10Pigeon interfaces to Swift, Kotlin, C++ and GObject
  • 138,973lines of Dart in the app and its packages, no tests
  • 0platform views on the game screen

Boundaries the code enforces

The first four are rejected by tools/check_imports.dart in the fast gate every merge goes through. The last two are architecture rules from AGENTS.md.

  1. check_imports.dart

    Rejected: import 'package:flutter/material.dart';

    Instead: import 'package:material_ui/material_ui.dart';

    Material and Cupertino only from the material_ui and cupertino_ui packages, never from the framework’s libraries.

  2. check_imports.dart

    Rejected: features/ → package:fluent_ui

    Instead: features/ → package:sudoku_design

    The screens and the board don’t know the kits. Kits live only in sudoku_design/lib/src/kits/.

  3. check_imports.dart

    Rejected: Duration(milliseconds: 350)

    Instead: motion.houseCompletion

    Motion only from the kit’s MotionTokens, each with a Reduce Motion variant.

  4. check_imports.dart

    Rejected: x << 3

    Instead: shl32(x, 3)

    Bits in the engine only through the bits.dart helpers, so the VM, dart2js and dart2wasm compute the same.

  5. AGENTS.md

    Rejected: compute(solve, grid)

    Instead: run.stepFor(budgetMicros)

    No compute() on the web and no blocking isolates: long work is cut into steps with a time budget.

  6. AGENTS.md

    Rejected: UiKitView(…)

    Instead: GlassSurface(…)

    No platform views on the game screen. Glass only by shader, and never over the digits.

Always the newest stable

Every task starts with tools/flutter_version.sh check. When there is a newer Flutter, the version goes up across the repo, but only if the full gate passes. If it doesn’t, the old one stays and the reason goes into the plan.

The web without isolates

The browser gets dart2wasm, with dart2js as the fallback. The engine runs in a Web Worker, and the page ships with COOP and COEP headers and a strict CSP: scripts only from its own origin, plus 'wasm-unsafe-eval'.

Apple TV without official support

Flutter doesn’t support tvOS, so Apple TV is built by the unofficial flutter-tvos on the same Flutter commit. There Platform.isIOS is true as well, so the code asks for isAppleTv separately.

Chapter 8: System features

Everything the system offers, not just a window with a game.

Widgets, tiles, menus, shortcuts and notifications: in each system, the ones that belong there. The statuses are honest: some Apple features are waiting for the developer account.

iOS · iPadOS

  • done

    A Control Center control

    A “Zagadka dnia” button in Control Center, on the Lock Screen and on the Action button (iOS 18).

  • done

    Siri and Shortcuts

    App Intents: daily, new game and continue — by voice, from Spotlight and in Shortcuts.

  • partly

    Apple Pencil

    A double-tap switches digits and notes, a squeeze undoes a move.

  • waiting for the Apple account

    Widgets and Game Center

    Ready in code; waiting for an App Group and the App Store Connect setup.

Android

  • done

    Three Glance widgets

    The daily with a thumbnail, continue game and the streak — on the home screen.

  • done

    A Quick Settings tile

    “Dzienna” one swipe down from the top of the screen.

  • done

    Icon shortcuts

    Static, dynamic and pinned; predictive back and foldables.

Windows

  • done

    A jump list

    Daily, new game and continue from the taskbar icon’s menu.

  • done

    Progress on the taskbar

    The app’s button shows how full the board is and turns yellow when paused.

  • done

    Snap Layouts

    An own Fluent title bar that still offers snap layouts on the maximise button.

macOS

  • done

    Dock: menu and badge

    A badge while today’s daily waits; a menu with the daily and recent .sudoku files.

  • done

    A real app menu

    PlatformMenuBar with states and key equivalents, a toolbar like NSToolbar.

Linux

  • done

    The XDG portal’s accent

    The accent colour, reduced motion and contrast flow live from the GNOME settings.

  • done

    .desktop actions

    Daily and new game from the icon’s menu; the reminder as an .ics calendar file.

Web

  • done

    Offline and WebAssembly

    Wasm with a JS fallback, an own service worker, a strict CSP and self-hosted fonts.

  • done

    Badge and sharing

    A dot on the icon while the daily waits; /p/ puzzle links, file and protocol handlers.

TV and beyond

  • done

    Apple TV · Android TV

    Played with the remote and a gamepad; on Apple TV through flutter-tvos.

  • done

    Cast to Nest Hub

    The puzzle on a Nest Hub screen; Android XR, Auto and Automotive too.

Chapter 9: Headsets

Two headset systems. The same board.

On Android XR headsets Sudoku is a panel in Home Space; on Apple Vision Pro, a window from the iPad. Both are the same package as on the phone and the tablet, with no separate version. The headset-only code is 38 lines of Kotlin that turn on the dark theme and 4 lines of Swift that turn off the haptics.

Android XR: resize the panel

These are the app’s real screens, drawn by the app itself at the panel sizes from the Android XR documentation, in the dark theme. Beside them, the board’s cell against Google’s touch target.

The game screen in an Android XR panel of 1024 × 720 dp, dark theme, the tablet layout: the board with the digit panel beside it.

1.75 m from the eyes

Panel
1024 × 720 dp
Layout
the tablet layout: the board with the digit panel beside it

A board cell68.5 dp

Google’s target: 48–56 dp

above the target · a 9×9 board: 616.5 dp

Above the target: a pinch lands on a cell without aiming.

The sizes to scale

Apple Vision Pro: the iPad window

On Vision Pro the iPad app runs as a compatible app: the same build and the same App Store record, with no separate version. Flutter doesn’t build natively for visionOS, so a “Designed for visionOS” version is out of the question.

The iPad game screen in a visionOS window: a 9×9 board with notes, and under it the digit keypad and the Notes, Erase, Undo, Redo and Hint buttons.
The iPad game screen (a store screenshot). The visionOS window around it is drawn by the page.
The window
iPad-sized; the player moves and resizes it. The layout is adaptive, as on an iPad in Stage Manager.
Input
A look and a pinch is a tap, a hold and a move drags; at most 2 touches at once. The keyboard, trackpad and a Bluetooth gamepad work as on the iPad.
The gaze highlight
The system draws it only for UIKit controls: the Apple kit’s native controls outside the game screen. It doesn’t highlight the Flutter board’s cells, but they are large.
Haptics
visionOS plays haptics as sound, which would double the game’s own sounds. From iOS 26.1 the app detects Vision Pro and turns the haptics off; the sounds play from the window.
What isn’t there
Widgets (visionOS doesn’t load them), Live Activities and CarPlay. A window in the background is dimmed, and the game saves its state on pause, as on the iPad.
As on the iPad
Game Center, the App Store rating and the reminders work just as on the iPad.
  • 2headset systems and no separate version: the phone’s AAB, the iPad’s build
  • 0 of 4hardware features in the Android manifest are required
  • 1.75 mfrom the eyes to the Android XR panel in Home Space
  • 68.5 dpa 9×9 cell in the default XR panel (target: 48–56 dp)
  • 38lines of Android XR-only Kotlin
  • 4lines of Vision Pro-only Swift

Side by side

Both systems run the same app, each in its own way.

WhatAndroid XRApple Vision Pro
LevelAndroid XR compatible adaptive appthe iPad app as a compatible app
Packagethe phone’s AAB; the Play Store offers it to headsets itselfthe same build and App Store record; available by default
On screena panel in Home Space, 1024 × 720 dp by default, 1.75 m from the eyesan iPad-sized window, moved and resized
Lookthe Material 3 Expressive kit, always darkthe Apple kit, as on the iPad
Inputpinch and hold; keyboard, mouse, trackpad, gamepadlook and pinch, at most 2 touches; keyboard, trackpad, gamepad
Headset-only codeXrHeadset.kt: the dark themeHaptics.swift: the haptics off
StoreGoogle Play: internal testApp Store: waiting for the Apple Developer account

All the headset-only code

Android XR is recognised by the android.software.xr.api.spatial system feature, Vision Pro by ProcessInfo.isiOSAppOnVision. The rest is the same code as on the phone and the iPad.

XrHeadset.kt
const val FEATURE_XR_SPATIAL = "android.software.xr.api.spatial"

fun isXr(context: Context): Boolean =
    context.packageManager.hasSystemFeature(FEATURE_XR_SPATIAL)

fun nightModeToSet(isXr: Boolean, sdk: Int, current: Int): Int? =
    if (isXr && sdk >= Build.VERSION_CODES.S && current != UiModeManager.MODE_NIGHT_YES) {
        UiModeManager.MODE_NIGHT_YES
    } else {
        null
    }
Haptics.swift
static let onVision: Bool = {
  if #available(iOS 26.1, *) { return ProcessInfo.processInfo.isiOSAppOnVision }
  return false
}()

What isn’t there yet, and why

Android XR: Full Space and 3D

Full Space, spatial panels, orbiters and depth are the Jetpack XR APIs (Compose for XR, SceneCore), still in alpha and beta. Flutter draws one surface, so the board becomes an object in space only once the game view is rewritten natively.

Vision Pro: Designed for visionOS

Flutter doesn’t build for visionOS, so there is no native target with volumes and space. The app stays an iPad window, and should anything block it, Vision Pro availability is switched off in App Store Connect without a new build.

A test on a headset

The XR emulator runs only in Android Studio Canary on an Apple-silicon Mac and on Windows, and the visionOS simulator shows neither haptics nor the gaze highlight. The device checklists wait in docs/qa-device-checklist.md.

Chapter 10: For everyone

For everyone, for years.

Accessibility is not a separate mode but a rule: tests keep the contrast, colour is never the only cue, and motion, haptics and sound each have three levels.

  • Screen readers

    Every move is announced: “7 placed. 4 sevens left.”, and on 16×16 “Letter A placed.”

  • Motion, haptics, sound

    Each on its own: full, reduced or off. Reduced motion turns movement into cross-fades.

  • Left-handed and gamepad

    A mirrored keypad layout and full gamepad, keyboard and mouse control.

  • 16×16 with a loupe

    Holding a cell shows a 3× loupe, and a minimap tells you where you are.

  • The first move within 5 seconds

    Onboarding is one question with three answers. The first useful tap comes within 5 s.

Colour is never the only cue

Eight Okabe-Ito colours to mark cells, each with its own glyph. Turn on the deuteranopia simulation: some colours merge, the glyphs stay.

  • orange
  • sky blue
  • bluish green
  • yellow
  • blue
  • vermilion
  • reddish purple
  • black

Four board grounds

  • 4738125571624398382964758327183719256414679832386594835283Light
  • 4738125571624398382964758327183719256414679832386594835283Dark
  • 4738125571624398382964758327183719256414679832386594835283OLED
  • 4738125571624398382964758327183719256414679832386594835283Paper

Craft

  • 219klines of Dart in 7 packages and the app
  • 3,184tests in 346 files
  • 280golden screenshots of the kits
  • 52achievements in 9 groups, no account

A “fast” gate before every merge: formatting, import rules, analysis with no warnings and every package’s tests. A “full” gate before every push: plus the engine’s determinism on dart2js and dart2wasm, the web, Linux and Android builds and the Swift tests. No switching tests off to get through.

Where it is today

  • liveWeb (PWA)sudoku.jakubnowak.euPlay
  • publishedMicrosoft Storesince 17.11.2026, x64 and arm64Open
  • publishedSnap Storesince 17.11.2026, LinuxOpen
  • in testingGoogle Playinternal test; a closed alpha in review
  • ready in the repoApp Store · Mac App Store · Apple TVwaiting for the Apple Developer account
  • ready in the repoAppGallery · Amazon Appstorepackages and listings generated from one source

Today’s puzzles are waiting.

The same on every screen, with no account and no ads. And if you want to talk about designing native apps for many platforms, write to me.