Dos negras por región, parejas sin fronteras
Norinori combines two compact rules. Every region must contain exactly two black cells, and every black cell must touch exactly one other black cell orthogonally, so black cells form isolated dominoes. A domino may cross a region boundary, which makes the rules interact rather than remain local.
Current status: verified engine, game still coming-soon
The native engine uses a 5×5 board, an independent solver and eight canonical transformed variants. The manifest is still coming-soon, so this article documents real verification without pretending public availability.
The domino is the real strategic unit
A single black cell is incomplete information. As soon as it is placed, the player needs to know which orthogonal neighbour can become its only partner. If two options remain, both can constrain different regions. Thinking in dominoes aligns human strategy with the solver model.
Regions control quantity, not partnership
A region needs two black cells, but those two do not have to form a domino with each other. Each may pair across a boundary. That freedom creates long-range dependencies and makes random region generation prone to ambiguity.
The first procedural generator failed the uniqueness gate
Earlier project attempts could construct boards that looked valid and had a known completion, yet the solver found alternatives. That failure turned uniqueness into an explicit quality requirement rather than an assumption.
A known completion is not a well-defined question
A constructed solution proves existence only. If the product promises uniqueness, it has to rule out alternatives. This principle is shared with other Blupoli generators even though each mechanic needs its own solver.
Retreating to verified fixtures was a quality decision
Instead of shipping doubtful infinite generation, the current engine starts from one canonical region pattern and derives eight rotations or reflections. Variety is smaller, but the important property is proven.
Eight transformations are not eight independently calibrated puzzles
Rotation and reflection preserve the underlying logical structure. They change orientation, not necessarily difficulty. Product copy should not present them as eight different levels unless measurements support that claim.
The self-test requires exactly one solution
For every variant, the engine solves with a limit of two and fails if the number of solutions is not exactly one. It also validates the returned completion against all rules. This is a clear guarantee for the current content set.
Stopping at two solutions saves work
Once a second solution exists, a candidate has already failed the uniqueness contract. There is no product value in discovering whether it has three or three hundred. The search budget can stop at the decision boundary.
Pruning needs both region and pairing rules
A region with too many black cells is immediately impossible. A black cell with more than one black neighbour is also impossible, as is a black cell that can no longer obtain any partner. Combining these local limits reduces search before branching.
White cells also carry information
Marking a cell white removes possible partners and can force the only remaining neighbour of another black cell. Negative state is therefore part of deduction, not simply absence of a mark.
Small or narrow regions are natural starting points
A region with few legal ways to place two black cells can force early decisions. The pairing rule then transports those decisions into neighbouring regions.
A black cell with one possible partner triggers multiple consequences
Its partner becomes black, while other orthogonal neighbours around the pair must remain non-black so that neither cell gains a second black neighbour. That can complete region counts and start a propagation chain.
Different dominoes cannot touch orthogonally
The manifest wording makes this consequence explicit: every black cell has exactly one orthogonal black neighbour. Diagonal contact is allowed. Solver, validator, onboarding and rules copy must all use the same semantic contract.
Validator and solver should agree without becoming the same code path
A complete-board validator can count black cells per region and verify orthogonal degree. The solver uses related rules to prune partial states. Retained fixtures should run through both and confirm agreement.
Current difficulty is not an open generated scale
With a small set of transformed fixtures, rich difficulty labels would be hard to justify without measurement. Solver instrumentation can eventually record propagation steps, branches and forced placements before any difficulty system is added.
A future generator must break symmetry intentionally
Random partitions failed because domino arrangements could often be rearranged while preserving region counts. A stronger generator should design regions that add specific information rather than hoping random boundaries eliminate alternatives.
Starting from controlled dominoes is one possible strategy
If the generator knows a domino structure first, it can build regions around it and test whether those boundaries suppress alternate pairings. Every mutation can be solution-counted before it is accepted.
Starting from low-domain regions is another strategy
Instead of arbitrary partitions, the generator can use shapes with few legal placements of two black cells. Combining constrained region motifs may create variety while controlling ambiguity.
The solver should guide generation rather than only judge the end
If a region mutation introduces a second solution, detecting that immediately allows rollback. Solver feedback can become part of construction rather than a final pass after expensive random work.
Any future procedural generator needs reproducible seeds
When an ambiguous or slow case appears, QA must reconstruct it exactly and retain it as a regression. Randomness without reproducibility would make solver development unnecessarily fragile.
Uniqueness search needs a time budget
A generator that experiments with many partitions can quickly become expensive. Search should have a deadline and a safe failure mode. Timeout must reject the candidate rather than being interpreted as evidence of uniqueness.
Timeout, ambiguity and contradiction are different outcomes
Ambiguity means constraints are too weak, contradiction means the structure is impossible, and timeout means evidence was too expensive to obtain. Keeping them separate makes generator tuning much more informative.
Onboarding can teach partnership before region counts
A small scene can show one black cell and ask where its only partner can go. A second step can introduce “exactly two black cells per region.” Teaching the rules in layers makes their interaction easier to understand.
Hints can name the forcing rule
A hint might say that a region already contains two black cells, so its remaining cells are white, or that one black cell has only one possible partner. These are domain explanations rather than arbitrary answers.
The UI must distinguish region, shading and pair status
Region boundaries need to remain visible without competing with black cells. Pair feedback can be subtle, but it should not introduce a visual line that looks like an additional rule unless the design explains it.
Responsive design must preserve region borders
A 5×5 board is compact, yet mobile scaling can still make thick boundaries and touch targets collide. Important separators should remain visually distinct at the smallest supported viewport.
Keyboard interaction can map black, white and unknown
A three-state cell model benefits from visible focus and clear keys. Shortcuts can accelerate play, but equivalent accessible controls should remain discoverable.
Persistence must retain regions and marks
A save needs variant identity or materialized regions plus every cell state. If the variant list changes later, a versioned identifier keeps historical games from loading with a different geometry.
Results can retain variant identity
Time and mistakes are interpretable only when the instance is known. A small variant code supports retries, sharing and support without exposing the hidden solution.
Retry should preserve geometry
Retry is useful because the player can learn the same logical structure. New game can select another transformation. The distinction should be explicit in both UI and results.
Transforms must preserve every semantic reference
Rotating or reflecting regions requires consistent coordinate mapping. The self-test over all eight variants doubles as protection against index mistakes introduced by transformations.
The canonical base deserves provenance
If the base pattern comes from a public puzzle ecosystem or an internal fixture, the repository should document origin and licensing where relevant. Technical transformation does not remove content provenance responsibilities.
The catalogue can describe shading, regions and pairing
These are observable activities and sufficient for discovery. There is no need for unsupported cognitive-training claims, following Blupoli's responsible taxonomy.
The editorial visuals explain both constraint layers
The new infographic shows regions that require two black cells and domino pairs crossing their borders. That relationship is the heart of the puzzle and more useful than a decorative screenshot.
Finishing Norinori means preserving its uniqueness standard
The current content set has a strong uniqueness guarantee. Product work still needs onboarding, responsive behaviour, accessibility, persistence, results and potentially a broader generation strategy that keeps the same standard.
The main lesson is choosing less content with stronger evidence
Norinori records an important project decision: when infinite generation could not prove uniqueness, the safer option was a small verified set. Scaling later from a trustworthy base is better than publishing ambiguity disguised as variety.
A richer generator should record why candidates fail
Counts of ambiguous, contradictory and timed-out attempts can show whether a new region strategy is improving. Generator health becomes measurable instead of being judged from a few visual samples.
Search ordering can use the most constrained cell
The solver can branch on a cell or region with the fewest legal options first. This fail-fast strategy tends to expose contradictions earlier and can reduce the cost of counting to two.
Region quotas provide strong lower and upper bounds
For every partial region, the solver knows how many black cells are already placed and how many undecided cells remain. If the quota of two can no longer be reached, or has already been exceeded, the branch can stop immediately.
Potential partner counts add another bound
A black cell whose remaining orthogonal neighbours are all white is impossible unless it already has exactly one black neighbour. Tracking this locally can prune branches before full validation.
White propagation can be aggressive after a pair is complete
Once a domino is fixed, all other orthogonal neighbours of its two cells must be white. That information can close neighbouring region quotas and reduce candidate partners elsewhere.
A hint system can expose those same propagation events
Instead of inventing a separate teaching solver, the engine can record semantic events such as “region quota complete” or “only partner remaining.” A product layer decides which event is understandable enough to show.
Semantic traces are more useful than recursion logs
A raw search trace says which bit changed. A semantic trace says why. That distinction matters if solver diagnostics later power hints, explanations or difficulty metrics.
Performance tests should keep the eight canonical variants forever
They form a natural regression set. Any solver optimization should return one solution for each and should not dramatically regress runtime. A small stable corpus is valuable even after a procedural generator arrives.
Future generated cases can join the corpus when they expose bugs
Every ambiguity bug or slow seed can become another retained fixture. The test suite then grows from real failure modes instead of only hand-selected happy paths.
The coming-soon state is useful, not embarrassing
It lets the project keep the strong algorithmic guarantee while finishing the surrounding experience at the same standard. Shipping later with evidence is preferable to changing the label early and discovering missing product layers in production.
The solver should branch on highly constrained states first
When several cells remain unknown, branching on any of them is correct but potentially expensive. Choosing a cell whose region is nearly complete or whose partner options are narrow tends to expose contradictions sooner. “Most constrained first” is especially natural because both region quotas and neighbourhood degree provide strong limits.
Region quotas provide lower and upper bounds
For every partial state, the solver knows how many black cells a region already contains, how many are still needed and how many unknown cells remain. More than two is impossible; fewer than two even after filling every unknown is also impossible. These cheap checks prune search early.
Potential partners add another pruning layer
A black cell without a black neighbour must retain at least one unknown neighbour that could become its partner. If none remain, the state is impossible. If exactly one remains, that cell is forced black and other orthogonal neighbours become white.
A completed domino propagates white cells around it
Once two black cells form their only mutual contact, every other orthogonal neighbour around both must be white. Those whites can complete region quotas and force new black cells elsewhere. The puzzle gains depth from alternating the two constraint systems.
Semantic traces can support future hints
Instead of recording only “cell 12 became black,” the solver can emit reasons such as “region quota complete,” “only partner remaining” or “completed pair forces white neighbours.” A hint layer can choose those reasons and explain them without exposing the complete search tree.
A recursion log is not an explanation
Backtracking order can depend on implementation heuristics and may not correspond to a useful human deduction. Separating semantic events from search steps lets the solver evolve without tying pedagogy to one recursion strategy.
The eight canonical variants should remain permanent regressions
Even after procedural generation arrives, the current fixtures remain valuable. They are small, understood and proven unique. Every solver refactor can compare solution count and runtime against them.
Future bugs can expand that corpus
Any ambiguous, slow or broken seed found during development can become another retained fixture. The suite then grows from real failure modes and documents the boundaries the engine has learned to protect.
A future generator should measure rejection reasons
If ninety-nine out of one hundred candidates are ambiguous, the construction strategy is probably not adding enough information. Counts of contradiction, ambiguity and timeout make generator experiments comparable before the team judges them by a handful of successful boards.
Uniqueness can guide mutation
One approach is to start from a unique instance, change one region boundary and count solutions. If a second solution appears, revert the change. This turns the solver into part of the generation loop rather than a final inspector.
Transforms can combine with verified local edits
Rotation and reflection provide free semantic variety. Small verified boundary changes on top of those transforms could expand content without rebuilding every candidate from random partitions. The solution counter remains the final authority.
Solver memory should be measured before scaling up
A 5×5 state is cheap, but larger future boards could copy many arrays per branch. Rollback or compact representations may become useful. Optimizing only runtime can hide unnecessary memory growth.
A worker can isolate expensive counting
If uniqueness search becomes perceptible, a Web Worker can protect the main thread. The worker contract should exchange serializable regions and states rather than DOM objects, and it needs cancellation for searches that belong to obsolete game sessions.
Mobile needs an explicit way to mark white
A three-state cell cycle has to work reliably on touch. Right-click cannot be a required interaction. Dedicated controls or clear cycling can work as long as targets are large and feedback is immediate.
Region borders are information, not decoration
Insufficient contrast can make two regions look like one and literally change how the puzzle is interpreted. Light and dark themes must preserve the hierarchy between normal grid lines and region boundaries.
Accessibility can expose region and neighbour context
A focused cell can announce row, column, state and region. A hint for a black cell may describe how many orthogonal partner positions remain. Translating spatial structure into text makes the mechanic more navigable.
Persistence should retain materialized geometry
A variant identifier is enough while the canonical list remains stable, but storing region geometry or a version protects historical saves from refactors. Cell state and undo history must refer to the same board definition.
Results should not mix variants without context
The transformations are logically equivalent, yet orientation can influence reading speed. A result can retain variant and engine version so comparison and support stay reproducible.
The coming-soon state is useful
It lets the project keep a strong algorithmic guarantee while finishing the product without pretending those are the same milestone. “Exactly one solution for every current fixture” and “complete public experience” remain separate statements.
Publication should require a cross-layer checklist
Beyond the solver self-test: mobile, keyboard, themes, reduced motion, onboarding, persistence, retry, results and restoration. The engine protects the mathematics; the platform has to protect everything around it.
Future variety must not weaken the current standard
Every generated board should meet at least the same evidence as the canonical variants: exactly one solution and a valid completion. More content should never mean less proof.
Norinori is also a lesson in knowing when to retreat
Replacing an ambitious generator with verified fixtures may look like a step backward in quantity, but it was a step forward in quality. Recognising that an algorithm is not production-ready is an engineering skill, not a failure.
Difficulty can eventually use semantic events
Counts of forced partners, completed-region propagations and search branches can provide a richer difficulty profile than raw solve time. The metrics correspond to puzzle concepts and are easier to explain than an opaque score.
Generated regions should preserve readability
A logically strong partition can still be visually poor if it creates tiny jagged shapes that are hard to follow. Future generation should include geometric constraints so correctness and readability are optimized together.
Region identifiers should be independent of visual colour
The domain can store integer region IDs while the UI chooses borders or subtle fills. Presentation can then change for accessibility without changing solver state or saved puzzles.
A completed board can be validated without the stored solution
Counting exactly two black cells in every region and verifying that every black cell has orthogonal degree one is enough to validate a final answer. This independent validator provides a second perspective from the search solution.
Completion validation should be retained as a property test
Every solution returned by the solver should satisfy the validator, and transformations should preserve that property. This catches mismatches between search pruning and final rule semantics.
Transforms deserve metamorphic tests
Rotating a valid puzzle and its solution should produce another valid puzzle with the same solution count. This relationship is a natural metamorphic property and protects coordinate-transform code.
Generated content can use the same metamorphic idea
If a future unique seed is rotated, uniqueness should remain. Transform-derived variants can therefore expand a tested corpus cheaply while still exercising rendering and persistence orientation changes.
Retry should not silently choose another transform
A player who retries expects the same board. New game may select another orientation. Preserving that semantic distinction makes improvement and bug reproduction meaningful.
Hints should remain valid after undo
Any cached suggestion derived from a later state must be discarded when the player undoes. Hint systems need to key advice to a state version rather than storing one global next move.
State versions also protect asynchronous solvers
If hint computation moves to a worker, the response should include the state version it analyzed. The UI can ignore stale suggestions from an earlier board state.
Publication should preserve provenance of the canonical fixture
Content origin and licensing are part of product hygiene. A transformation does not erase where the base came from. Repository documentation should keep that context alongside technical tests.
Related context: generation needs independent verification, one solver does not fit every puzzle, and the catalogue taxonomy.