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.
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.
- 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.
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.
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.
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.
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.
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).
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.
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

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.
Screenshots from the app
The store screenshots: each platform in its own kit, rendered by the app’s code — the same code that runs natively.
iPhone · Liquid GlassA 9×9 game: corner notes, a keypad counting the digits still missing. Android · Material 3 ExpressiveThe same game in Material 3 Expressive: tonal surfaces and rounded keys. macOS · TahoeThe Mac window: sidebar, board, timer and the keyboard shortcut sheet. Windows 11 · FluentA hint on Windows: the board dims outside the box and the panel names the technique. Linux · AdwaitaGNOME: the libadwaita header bar and the accent from the system settings. iPad · Liquid Glass16×16 on the iPad: digits and the letters A–G, a 4×4 keypad. Android · tabletThe daily puzzles on a tablet: three tiers, the streak and the month’s calendar. Android TVOn the TV: a large board, played with the remote or a gamepad. Windows 11 · Fluent16×16 on Windows with the keyboard shortcut panel. Linux · AdwaitaDaily in Adwaita: Quick 6×6, Classic and Expert 9×9.
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.
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.
- Where to lookThe board dims outside the place where the move is. Sometimes that is enough.
- Which techniqueA sheet with the technique’s name and its rule in one sentence. The pattern appears on the board.
- 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.
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.
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.
iPhone · Liquid GlassThe X-Wing lesson on the iPhone. macOS · TahoeThe same lesson on the Mac.
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.
- DateThe player’s local calendar day.
- FNV-1aThe text “v1|date|tier” becomes a 32-bit number.
- Pool indexThe remainder by the pool’s size points to a puzzle in daily_v1.bin.
- Sfc32Our own generator, seeded by a second hash, permutes digits, rows and columns.
- The same gridEvery device arrives at the same grid, bit for bit.
Day
Quick6×6 · Medium
- key
v1|2026-11-19|quick- FNV-1a
0xFE53D263- pool: 1200 · puzzle #211
4266906211 mod 1200 = 211- Sfc32 seed
4173149746
Classic9×9 · Medium
- key
v1|2026-11-19|classic- FNV-1a
0x875B8EBC- pool: 800 · puzzle #476
2270924476 mod 800 = 476- Sfc32 seed
228028977
Expert9×9 · Master
- 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
- Engine
sudoku_enginePlain Dart, no dependencies; the same result on the VM, in dart2js and in dart2wasm (shared, the same path) - Board
sudoku_boardDrawn by its own code, no kit widgets; a completed house’s sweep is a shader (shared, the same path) - Game and screens
app/libRiverpod and go_router; the screens know only the sudoku_design facade (shared, the same path) - Haptics and sound
sudoku_feedback42 moments from one matrix, each with a Reduce Motion variant (shared, the same path) - Data
sudoku_dataSQLite through drift (shared, the same path) - Kit
sudoku_designLiquid Glass from iOS 26, Cupertino before (the platform’s own path) - Bridge to the system
sudoku_platformPigeon → Swift: 7 interfaces (the platform’s own path) - Compilation
flutter buildAOT to machine code (shared, the same path) - Package and store
release.ymlIPA → App Store; waiting for the Apple Developer account (the platform’s own path)
The code on this platform
- Dart
- 97.0%138,973 lines
- Swift
- 3.0%4,179 lines
Lines of code without tests, tools or generated files, counted on 19 Nov 2026. The Dart is the packages and the app: the same on every platform.
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.
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.
check_imports.dart
Rejected:
features/ → package:fluent_uiInstead:
features/ → package:sudoku_designThe screens and the board don’t know the kits. Kits live only in sudoku_design/lib/src/kits/.
check_imports.dart
Rejected:
Duration(milliseconds: 350)Instead:
motion.houseCompletionMotion only from the kit’s MotionTokens, each with a Reduce Motion variant.
check_imports.dart
Rejected:
x << 3Instead:
shl32(x, 3)Bits in the engine only through the bits.dart helpers, so the VM, dart2js and dart2wasm compute the same.
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.
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.

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 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.
| What | Android XR | Apple Vision Pro |
|---|---|---|
| Level | Android XR compatible adaptive app | the iPad app as a compatible app |
| Package | the phone’s AAB; the Play Store offers it to headsets itself | the same build and App Store record; available by default |
| On screen | a panel in Home Space, 1024 × 720 dp by default, 1.75 m from the eyes | an iPad-sized window, moved and resized |
| Look | the Material 3 Expressive kit, always dark | the Apple kit, as on the iPad |
| Input | pinch and hold; keyboard, mouse, trackpad, gamepad | look and pinch, at most 2 touches; keyboard, trackpad, gamepad |
| Headset-only code | XrHeadset.kt: the dark theme | Haptics.swift: the haptics off |
| Store | Google Play: internal test | App 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.
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
}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
- Light
- Dark
- OLED
- Paper
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.
















