DEV Community: Anson Chan

Free Online Slitherlink: 3000+ Puzzles with 10 Difficulty Levels

Anson Chan — Wed, 18 Feb 2026 14:48:15 +0000

I built Slitherlink Online because every existing Slitherlink site had the same problems: ugly UI, no difficulty control, no way to track progress. Here's what's different.

What is Slitherlink?

Slitherlink (also called Fences or Loop the Loop) is a logic puzzle invented by the Japanese publisher Nikoli. You're given a grid of dots with numbers in some cells. Your job: draw a single closed loop using the edges between dots, where each number tells you exactly how many of its surrounding edges are part of the loop.

It's pure logic — no math, no vocabulary, no cultural knowledge. Just pattern recognition and deduction. That's why it works across languages.

The Puzzle Collection

3000+ hand-quality puzzles generated by a custom Rust engine (not random placement):

Grid Size	Cells	Difficulty Range	Typical Solve Time
5×5	25	Level 1-4	1-5 minutes
7×7	49	Level 2-6	3-10 minutes
8×8	64	Level 3-7	5-15 minutes
10×10	100	Level 4-8	10-30 minutes
12×12	144	Level 5-8	20-60 minutes

Every puzzle has been verified to have exactly one solution. The difficulty rating measures what solving techniques are required, not just "how many clues are missing." A Level 1 puzzle needs only corner rules. A Level 8 puzzle needs loop closure logic and multi-step reasoning.

Daily Challenges

Every day at midnight UTC, a new puzzle is selected as the daily challenge. Everyone gets the same puzzle. Solve it, submit your time, and see where you rank on the leaderboard.

This creates a shared experience — you can discuss today's puzzle with friends, compare strategies, and see if your approach was efficient. The daily challenge rotates through different grid sizes and difficulties.

What the UI Actually Looks Like

Dark mode only — no eye strain during evening puzzle sessions
Emerald accent colors — clean, minimal, professional
Touch-optimized mobile UI — tap edges to draw lines, tap again for × marks
No ads (yet) — the focus is on the puzzle, not monetization
5 languages — English, Japanese, Chinese, Korean, Turkish

The game engine runs on Phaser 3 with Canvas rendering. Lines snap to grid edges with clear visual feedback. Completed loops highlight in green. Invalid states show warnings.

For the Technically Curious

The entire platform runs on Cloudflare's free tier:

Frontend: Next.js static export on Cloudflare Pages (global CDN, < 50ms TTFB)
API: Cloudflare Worker handling puzzle serving, auth, game completion, leaderboards
Database: Cloudflare D1 (SQLite at the edge) storing all puzzles and user data
Puzzle Engine: Custom Rust binary for batch generation, compiles to WASM for browser-side validation

Monthly hosting cost: $0. The entire 3000-puzzle database is 1.9MB in D1.

How Difficulty Rating Works

Most puzzle sites rate difficulty by counting missing clues. That's lazy and inaccurate. Our Rust engine simulates a human solver:

Apply the simplest technique (corner rules). If it makes progress, stay at Level 1.
If stuck, try the next technique (adjacent patterns). If needed, bump to Level 3.
Continue through vertex rules (Level 5), loop closure (Level 7), and bifurcation (Level 9).
The highest technique needed = the puzzle's difficulty level.

This means a Level 3 puzzle genuinely requires intermediate techniques. A Level 7 puzzle will force you to use loop closure logic — guaranteed.

Getting Started

New to Slitherlink? Start with the corner patterns guide — learn the four corner rules (0, 1, 2, 3 in corners) and you can solve any Level 1-2 puzzle.

Ready to play? Pick 5×5, Easy difficulty, and go: slitherlinks.com

Building a Slitherlink Puzzle Engine in Rust + WebAssembly

Anson Chan — Wed, 18 Feb 2026 14:41:23 +0000

Most puzzle websites generate puzzles with simple random placement. We built a proper constraint-based engine in Rust that generates, solves, and rates Slitherlink puzzles on a 10-level difficulty scale — then compiles to WebAssembly for browser use.

Why Rust?

Slitherlink generation is computationally expensive. A 10×10 grid has 220 possible edges. The engine needs to:

Generate a valid closed loop
Place number clues
Verify the puzzle has exactly one solution
Rate the difficulty based on required solving techniques

JavaScript couldn't handle this efficiently. Java was our first attempt (it worked), but Rust gave us 10-50x speedup and the option to compile to WASM for client-side solving.

The Architecture

Phase 1: Loop Generation

Start with an empty grid. Build a random Hamiltonian-like path that forms a single closed loop:

·───·   ·───·───·
│       │       │
·   ·───·   ·   ·
│   │       │   │
·   ·   ·───·   ·
│   │   │       │
·───·   ·───·───·

The algorithm uses randomized DFS with backtracking. Key constraint: every vertex touched by the loop must have exactly degree 2 (one line enters, one leaves).

Phase 2: Clue Placement

Count the edges around each cell to generate numbers:

·───·   ·───·───·
│ 2   1 │ 2   3 │
·   ·───·   ·   ·
│ 2 │ 2     2 │ 2
·   ·   ·───·   ·
│ 1 │ 1 │ 2   2 │
·───·   ·───·───·

Then selectively remove some numbers to create the puzzle. More numbers removed = potentially harder puzzle, but difficulty depends on which numbers remain, not just how many.

Phase 3: Uniqueness Verification

This is the expensive part. The solver must confirm exactly one solution exists by:

Constraint propagation: Apply all known patterns (corner rules, adjacent 3-3, vertex degree) exhaustively
Backtracking: When propagation stalls, pick an undecided edge, try both states (line/no-line), propagate each branch
Uniqueness check: If both branches lead to valid solutions, the puzzle has multiple solutions — reject it

solve(puzzle):
    propagate all constraints
    if contradiction → no solution
    if all edges decided → one solution found
    pick undecided edge E
    try E = line:
        solutions_a = solve(puzzle + E=line)
    try E = no_line:
        solutions_b = solve(puzzle + E=no_line)
    return solutions_a + solutions_b
    // if total > 1, puzzle is ambiguous — reject

Phase 4: Difficulty Rating (10 Levels)

This is where it gets interesting. We don't just count clues — we measure what techniques are required to solve:

Level	Techniques Required
1-2	Corner rules, 0-elimination only
3-4	Adjacent number patterns (3-3, 3-0)
5-6	Vertex degree rule, edge patterns
7-8	Loop closure logic, inside/outside reasoning
9-10	Multi-step bifurcation (trial and error)

The rating engine simulates a human solver: apply techniques in order of complexity, track which level of technique was needed to make progress. The highest technique level used = the puzzle's difficulty.

fn rate_puzzle(puzzle: &Puzzle) -> u8 {
    let mut max_level = 1;
    let mut state = SolverState::new(puzzle);

    loop {
        // Try techniques from simplest to most complex
        if state.apply_corner_rules() { max_level = max(max_level, 1); continue; }
        if state.apply_adjacent_patterns() { max_level = max(max_level, 3); continue; }
        if state.apply_vertex_degree() { max_level = max(max_level, 5); continue; }
        if state.apply_loop_closure() { max_level = max(max_level, 7); continue; }
        if state.apply_bifurcation() { max_level = max(max_level, 9); continue; }
        break;
    }
    max_level
}

Compiling to WebAssembly

The Rust engine compiles to WASM via wasm-pack:

wasm-pack build --target web --release

The resulting .wasm binary is ~200KB and runs in the browser for:

Client-side puzzle validation (anti-cheat)
Hint generation
Solution verification

For batch generation (we pre-generate 3000+ puzzles), we use the native binary:

./slitherlink-engine gen --grid-size 10 --level 6 --count 100

This outputs JSON to stdout — one puzzle per line with grid_size, clues, solution, and difficulty rating.

Production Pipeline

Rust engine (batch generate)
    → JSON puzzles
    → Import to Cloudflare D1 database
    → CF Worker API serves puzzles
    → Next.js frontend renders with Phaser 3

The database holds 3000+ puzzles across 5 grid sizes (5×5, 7×7, 8×8, 10×10, 12×12) and 10 difficulty levels. The API supports random puzzle selection filtered by size and difficulty, daily challenges, and leaderboards.

Numbers

Generation speed: ~50 puzzles/minute for 10×10 Level 5-6
WASM bundle: 200KB gzipped
Solve time (WASM, 10×10): < 100ms
Database: 3000+ puzzles, 1.9MB total in D1

Try It

Play the puzzles at slitherlinks.com — the difficulty ratings are real. Level 1 feels gentle; Level 8 will make you sweat.

Slitherlink Corner Patterns: The Complete Visual Guide

Anson Chan — Wed, 18 Feb 2026 14:33:09 +0000

Slitherlink is a logic puzzle where you draw a single closed loop on a grid using number clues. Each number tells you how many of its four surrounding edges are part of the loop. No number? That cell could have any count.

Corners are where you should always start solving — they have fewer edges (only 2 outer edges touching the grid boundary), which means fewer possibilities and faster deductions.

The Rules, Briefly

Draw lines on grid edges to form one continuous closed loop
Each number = count of lines around that cell
The loop cannot branch or cross itself
Every vertex (dot) has either 0 or exactly 2 lines passing through it

Corner 0: Instant Elimination

A 0 in the corner means zero lines around it. Since a corner cell has only 2 outer edges, both are eliminated immediately — plus the 2 inner edges.

·   ·   ·
  × 0 ×  
· × · × ·

Why it works: 0 means no lines at all. Mark all 4 edges with × and move on. This is the single fastest deduction in the game.

Pro tip: After marking a corner 0, check the adjacent cells. If there's a 3 next to a 0, you just eliminated one of the 3's edges — forcing the remaining 3 edges to all have lines.

Corner 3: Two Guaranteed Lines

A 3 in the corner needs 3 out of 4 edges to have lines. But the corner vertex only connects to 2 outer edges. If either outer edge had no line, the vertex would need the line to come from somewhere — but there's nowhere else to go without violating the loop rule.

·───·   ·
│ 3      
·   ·   ·

Both outer edges must have lines. That gives you 2 out of 3 lines immediately. The third line is one of the 2 inner edges — you'll determine which one from neighboring clues.

Why it works: Consider the corner vertex (top-left). The loop requires 0 or 2 lines at each vertex. The outer edges are the only ones connecting to this vertex. If one were missing, you'd have exactly 1 line at the vertex — a dead end, which is illegal.

Corner 1: Both Outer Edges Are Empty

This one surprises beginners. A 1 in the corner means neither outer edge can have a line.

· × ·   ·
× 1      
·   ·   ·

Why it works: Suppose one outer edge has a line. The corner vertex now has exactly 1 line. To satisfy the vertex rule (0 or 2 lines), the other outer edge must also have a line — but then we'd have 2 lines, making this cell at least a 2, not a 1. Contradiction.

So both outer edges must be ×, and the single line for this 1 comes from one of the 2 inner edges.

Corner 2: The Paired Pattern

A 2 in the corner has an elegant constraint: the two outer edges are always the same — either both have lines, or both are empty.

Case A — both outer edges have lines (2 of 2 accounted for, inner edges empty):

·───·   ·
│ 2      
·   ·   ·

Case B — both outer edges empty (both lines come from inner edges):

·   ·   ·
    2    
· × ·───·

Why it works: If only one outer edge had a line, the corner vertex would have exactly 1 line — a dead end. So they must match: both on or both off. You need more information from neighboring cells to determine which case applies.

Combining Corner Patterns with Neighbors

Corner 3 + Adjacent 3 (The S/Z Shape)

When a corner 3 sits next to another 3, you get one of the most powerful patterns in Slitherlink — 5 edges determined at once:

·───·   ·───·
│ 3 │ 3 │
·   ·───·   ·

The shared edge between the two 3s always has a line. Combined with the corner 3's two outer lines, and the second 3 needing its own 3 lines, you get an S-shaped (or Z-shaped) pattern.

Mirror version:

·   ·───·   ·
│ 3 │ 3 │
·───·   ·───·

Corner 3 + Adjacent 0

When a 0 sits next to a corner 3, the 0 eliminates their shared edge. Since the corner 3 already has 2 outer lines, the third line must go to the remaining inner edge:

·───·   ·   ·
│ 3 × 0 ×    
·───· × · × ·

All 3 of the corner 3's lines are now fully determined.

The Vertex Rule: Why These Patterns Work

Every pattern above derives from one principle: each vertex has 0 or 2 lines.

This is because the loop is continuous — if a line enters a vertex, it must also leave. No dead ends allowed. This constraint, combined with corner geometry (only 2 outer edges meet at the corner vertex), makes corners the most constrained — and therefore most solvable — cells on the board.

Practice Strategy

Scan all 4 corners first — process 0s, 3s, and 1s immediately
Check neighbors of corner cells — propagate constraints outward
Look for edge cells next — they have 3 edges (1 outer), similar constraints
Work inward — interior cells have 4 edges and need more context

Start with easy 5×5 puzzles where corners dominate the grid. As you scale to 10×10 and 15×15, corner patterns still fire first — but you'll need intermediate and advanced techniques for the interior.

Try these patterns on real puzzles: slitherlinks.com — 3000+ free puzzles across 5 grid sizes and 10 difficulty levels. Start with 5×5 Level 1 to practice corner patterns in isolation.

The Zero-Cost Stack: Building a Global Web App with Cloudflare Free Tier

Anson Chan — Wed, 18 Feb 2026 07:24:00 +0000

What if I told you that you could deploy a web application serving users globally — with a database, API, static hosting, and custom domain — for exactly $0 per month?

No catch. No "free for 30 days." Actually free, indefinitely.

The Stack

Here's what I use to run two production web applications (Slitherlinks and OmniConvert) at zero cost:

Cloudflare Pages — Static site hosting with global CDN
Cloudflare Workers — Serverless API endpoints
Cloudflare D1 — SQLite database at the edge
Cloudflare R2 — Object storage (if needed)

All on the free tier. Let me break down each component.

Cloudflare Pages: Global CDN for Free

Pages gives you:

Unlimited bandwidth
Unlimited requests
500 builds per month
Preview deployments for every branch
Custom domains with automatic SSL

My Slitherlinks frontend is a static site built with HTML, CSS, and vanilla JavaScript. Every deployment pushes to Cloudflare's global CDN — 300+ data centers worldwide. A user in Tokyo gets the same sub-50ms response time as a user in São Paulo.

Deployment is one command: wrangler pages deploy dist/

Cloudflare Workers: API Without Servers

Workers run JavaScript/TypeScript at the edge. Free tier gives you:

100,000 requests per day
10ms CPU time per request
Global deployment (runs in the nearest data center to the user)

My Slitherlinks API handles puzzle delivery, user authentication, game completion tracking, leaderboards, and daily challenges — all in a single Worker.

The Worker code is surprisingly simple. It's essentially a router that maps endpoints to handler functions, with D1 database access.

Cloudflare D1: SQLite at the Edge

D1 is the game-changer. It's a serverless SQLite database that:

Replicates globally (reads are fast everywhere)
Supports standard SQL
Free tier: 5M reads, 100K writes per day
5GB storage

My D1 database stores 1,900 puzzles across 5 grid sizes and multiple difficulty levels, plus user accounts, game history, and leaderboard data. Total size: about 2MB.

For a puzzle game, 5M reads/day is essentially unlimited. I could serve thousands of daily active users before touching any limits.

The Authentication Pattern

One thing that surprises people: you can build real authentication on this stack. My implementation uses:

PBKDF2 password hashing (100K iterations, SHA-256)
HMAC-SHA256 JWT tokens (30-day expiry)
JWT_SECRET stored as a Worker secret

No third-party auth service needed. The Worker handles registration, login, and token verification directly.

Why Not Vercel/Netlify/Railway?

These are excellent platforms. But they all have usage-based pricing that kicks in at scale. Vercel's free tier limits bandwidth to 100GB. Netlify's limits to 100GB. Railway charges per resource-hour.

Cloudflare's free tier has no bandwidth limits on Pages and generous daily request limits on Workers. For applications that are read-heavy (like a puzzle game or a file converter), this is effectively unlimited.

Real Numbers

Here are my actual usage stats for Slitherlinks:

Pages: ~2,000 requests/day, 0% of any limit
Workers: ~500 API calls/day, 0.5% of daily limit
D1: ~3,000 reads/day, 0.06% of daily limit
Monthly cost: $0.00

Even if traffic 10x'd, I'd still be comfortably within free tier.

The Trade-offs

It's not perfect:

Workers have 10ms CPU limit on free tier (enough for most API work, tight for heavy computation)
D1 is eventually consistent for global reads (fine for games, tricky for financial applications)
No WebSocket support on free Workers (use Durable Objects on paid tier)
Cold starts exist but are minimal (~5ms)

For most indie projects, these limitations don't matter.

Getting Started

Sign up at cloudflare.com (free)
Install Wrangler: npm install -g wrangler
Create a Pages project: wrangler pages project create my-app
Create a D1 database: wrangler d1 create my-db
Create a Worker: wrangler init my-api
Deploy and forget about hosting costs forever

Both Slitherlinks and OmniConvert run on this exact stack. Zero monthly cost, global performance, scales automatically.

The best infrastructure is the one you never have to think about.

See it in action: slitherlinks.com | tools.sagasu.art

Daily Puzzle Challenges: How Routine Problem-Solving Sharpens Your Mind

Anson Chan — Wed, 18 Feb 2026 07:23:31 +0000

The Gym for Your Brain

We all know the physical benefits of a daily routine. You go to the gym to keep your muscles strong. You go for a run to keep your heart healthy. You stretch to maintain flexibility.
But what about your brain?

In our modern world of doom-scrolling and passive content consumption, our brains often lack the "resistance training" they need to stay sharp. We consume information, but we rarely synthesize it or solve novel problems under constraints.

This is where the concept of the Daily Puzzle Challenge comes in.

Just as lifting weights tears down muscle fibers to build them back stronger, struggling with a difficult logic puzzle forces your brain to create new neural pathways. It is cognitive exercise. And like physical exercise, consistency is key.

This philosophy is the driving force behind the daily challenges at Slitherlinks.com/en/daily-challenge.

The Science of Neuroplasticity

For a long time, scientists believed the brain stopped developing after childhood. We now know this is false. The concept of neuroplasticity tells us that the brain is capable of reorganizing itself throughout life.

When you engage in routine problem-solving—specifically logic puzzles like Sudoku, Crosswords, or Slitherlink—you are engaging the prefrontal cortex. This is the area responsible for executive function: planning, decision making, and moderating social behavior.

A study published in the International Journal of Geriatric Psychiatry found that the more often people aged 50+ engaged in puzzles, the better their brain function. The researchers found that frequent puzzle solvers had brain function equivalent to bodies up to 10 years younger than their actual age.

But it's not just for the elderly. For software engineers, writers, and knowledge workers, these puzzles act as a "warm-up" for the day.

Why "Daily" Matters

You can't go to the gym once a month for 10 hours and expect to get fit. You'll just get injured.
Similarly, binge-solving puzzles for 5 hours on a Sunday is less effective than solving one 10-minute puzzle every morning.

1. The Ritual Effect:
Starting your day with a small win sets a psychological tone. Completing a daily challenge gives you a dopamine hit before you've even checked your email. It says, "I am capable of solving problems today."

2. Pattern Recognition:
Daily exposure keeps the patterns fresh in your working memory. If you solve a Slitherlink puzzle today, and then another tomorrow, your brain retains the geometric heuristics (like the corner patterns we discussed in other articles). If you wait a week, you have to "re-load" that context.

3. Cognitive Switching:
The act of switching from "sleep mode" or "coffee mode" to "analytical mode" is a skill in itself. Daily puzzles train you to switch into deep focus on command.

The Slitherlink Daily Challenge

At Slitherlinks.com, we designed the Daily Challenge to be the perfect dose of cognitive caffeine.

Here is how it is structured:

Consistency: A new puzzle is generated every 24 hours.
Variety: The size and difficulty rotate. Some days are a quick 5-minute breeze; other days are a 20-minute grinder. This prevents your brain from getting too comfortable.
Community: Everyone solves the exact same puzzle. This is crucial. It creates a shared experience. You can compare your time with friends or the global leaderboard. Did you get stuck on the top-right corner? So did everyone else.

Logic Puzzles vs. "Brain Training" Games

A note of caution: There is a difference between pure logic puzzles and the gamified "Brain Training" apps that were popular a few years ago.
Many "Brain Training" apps claim to improve general IQ, but studies show they mostly just make you better at playing that specific game.

Logic puzzles like Slitherlink are different because they rely on deductive reasoning, not just reaction time or memorization.
In Slitherlink, you cannot guess. Guessing leads to failure. You must prove to yourself that a line exists or doesn't exist based on the evidence.
This mindset—Evidence-Based Decision Making—transfers directly to programming, debugging, and engineering.

When I am debugging a complex race condition in code, the mental motion is identical to solving a hard Slitherlink board:
"If this variable is true, then that function must have fired. But if that function fired, the log would show X. The log does not show X. Therefore, the variable is false."

That is Slitherlink. That is logic.

How to Integrate This into Your Routine

You don't need hours. You need 10 minutes.

Anchor it: Tie the habit to something you already do. "I will do the Daily Challenge while I drink my morning coffee."
No distractions: Don't do it while watching TV. Give it 100% of your focus. This trains your attention span.
Review your mistakes: If you break the loop, don't just restart blindly. Look at why you broke it. Did you make an invalid assumption?

Conclusion

Your mind is a tool. Like any tool, it needs maintenance.
The "use it or lose it" adage applies to cognitive function just as much as muscle mass.

By incorporating a small, high-quality logic puzzle into your daily routine, you aren't just passing time. You are sharpening the blade you use to attack the rest of your day's problems.

Ready to test your focus? Try today's challenge at Slitherlinks.com/en/daily-challenge.

Why I Built a File Converter That Doesn't Upload Your Files

Anson Chan — Wed, 18 Feb 2026 07:18:20 +0000

The Problem with Cloud Converters

We've all been there. You have a PNG you need as a JPG. You have a WAV file you need as an MP3. Or maybe a JSON file you need to convert to YAML.
You Google it. You click the first result: "Free Online Converter!"
It asks you to upload your file.
You hesitate.

Maybe that file is a scan of your ID.
Maybe it's a financial spreadsheet.
Maybe it's a confidential work document.
Or maybe it's just a personal photo you'd rather not share with a random server in a jurisdiction you can't pronounce.

But you're in a hurry. You upload it. You wait for the progress bar. You download the result. And you hope that "Delete after 24 hours" promise is actually true.

This workflow is broken. In 2026, with the computing power available in our web browsers, there is absolutely no reason to send a 5MB image to a server halfway across the world just to change its file format.

That is why I built Sagasu Tools.

The Paradigm Shift: Local-First Web Apps

The web has evolved. It used to be a dumb terminal for displaying text. Then it became a way to send forms to servers.
Today, the browser is a full-fledged operating system.
With technologies like WebAssembly (Wasm), Service Workers, and the File System Access API, we can bring desktop-class performance and privacy to the web.

My goal with tools.sagasu.art was simple: Zero server-side processing.

How It Works

When you visit a traditional converter site:

Client: Select file -> Upload (Bandwidth cost + Privacy risk)
Server: Receive file -> Spin up process -> Convert (CPU cost) -> Save temp file
Client: Download result (Bandwidth cost)

When you use Sagasu Tools:

Client: Select file -> Browser processes it locally -> Save result.

There is no step 2. The server serves the static HTML/JS/Wasm assets once, and then gets out of the way. You could literally turn off your Wi-Fi after the page loads, and the tool would still work.

Under the Hood: FFmpeg.wasm and Friends

The secret sauce for many media converters today is FFmpeg. It's the Swiss Army knife of audio/video processing.
Traditionally, FFmpeg runs on Linux servers. But thanks to the Emscripten compiler toolchain, we can compile FFmpeg's C code into WebAssembly.

ffmpeg.wasm allows the browser to run FFmpeg directly in a Web Worker.
This means when you convert a video on my site, your CPU fan might spin up, but your network card stays quiet. The data never leaves your RAM.

This approach has massive benefits:

Privacy: This is the big one. If the data never leaves your device, it can't be intercepted, stored, or sold. It is GDPR-compliant by design because there is no data processing happening on my end.
Speed: For many files, uploading and downloading takes longer than the actual conversion. Local conversion is instant for small files.
Cost: I don't pay for expensive GPU cloud instances to process video. I host static files. My hosting bill is effectively zero (thanks to Cloudflare Pages), which allows me to offer the tool for free without plastering it with ads.
Reliability: No "Server Overloaded" errors. If your computer is working, the tool is working.

The Challenges of Client-Side Processing

It's not all sunshine and rainbows. Building a local-first converter comes with trade-offs.

1. Browser Constraints:
Browsers sandbox everything. Managing memory in WebAssembly can be tricky. If you try to convert a 4GB video file in Chrome, you might crash the tab because the browser limits how much RAM a single tab can use.
Cloud servers can throw 128GB of RAM at a problem. Your browser tab gets maybe 4GB.

2. Initial Load Time:
The ffmpeg.wasm core is large (around 25MB). Downloading this takes time on the first visit.
Solution: I use aggressive caching. Once you've visited the site once, the Wasm binary is stored in your cache. Subsequent visits are instant.

3. Format Support:
While FFmpeg is extensive, compiling every codec into Wasm bloats the file size. I have to be selective about which formats to support to keep the app lightweight.

Beyond Media: Unit Conversion, JSON, and More

While media conversion is the flashy use case, the same local-first philosophy applies to everything on tools.sagasu.art.

JSON Formatter: Why send your config files to a server to pretty-print them? Do it in JS.
Base64 Encoder: This is a simple string manipulation. It should never touch a backend.
Unit Converter: Pure math. Zero latency.

Why This Matters

We are seeing a swing back towards "thick clients."
In the 90s, we installed .exe files.
In the 2010s, we moved everything to the cloud (SaaS).
In the 2020s, we are moving back to the edge and the client, but delivered via the web.

This hybrid model—Web distribution, Local execution—is the future of utility software. It combines the friction-free access of a website (no install required) with the privacy and performance of a desktop app.

I built this converter because I wanted to use it. I wanted a bookmark I could click, drag a file onto, and get a result, without worrying about who is looking at my data.

If that sounds like something you need, give it a try at tools.sagasu.art. No signup, no upload, no nonsense. Just tools.

Slitherlink Corner Patterns: The First Thing Every Solver Should Learn

Anson Chan — Wed, 18 Feb 2026 07:11:37 +0000

Introduction

If you've ever stared at a Slitherlink grid, feeling a mix of intrigue and intimidation, you're not alone. This logic puzzle, also known as Fences or Loop the Loop, offers a pure test of deductive reasoning. Unlike Sudoku, which relies on placing numbers, Slitherlink is about topology and geometry—constructing a single continuous loop.

For beginners, the grid can seem chaotic. But experienced solvers know that the chaos is an illusion. The grid is governed by strict rules, and these rules create predictable patterns. The most fundamental of these patterns are found in the corners.

Understanding corner patterns is the "Hello World" of Slitherlink strategy. It is the first step in transforming from a guesser into a solver. In this guide, we will dissect the corner cases for 0, 1, 2, and 3, giving you the tools to break into any grid with confidence.

If you want to practice these patterns immediately, you can find thousands of puzzles at Slitherlinks.com, a modern, clean interface for solving these logic gems.

The Rules of the Game

Before we dive into the corners, let's briefly recap the rules to ensure we are on the same page:

Connect adjacent dots with vertical or horizontal lines to form a single loop.
The numbers inside the squares indicate how many of its four sides are part of the loop.
The loop cannot cross itself or branch off.
Empty squares can have any number of lines (0, 1, 2, or 3) bordering them, but usually not 4 (unless it's a tiny 1x1 loop, which is trivial).

why Start with Corners?

Corners are powerful because the geometry is constrained. A cell in the middle of the board has four potential neighbors. A cell on the edge has three. But a corner cell? It has only two external edges available to the grid boundary. This constraint drastically limits the possibilities for the loop, forcing specific line placements based on the clue number.

Let's break them down number by number.

The Corner 0

This is the easiest pattern to spot and the most immediately gratifying.

The Logic:
A '0' clue means none of the four sides of that square can contain a line segment.

The Result:
You can immediately mark "x"s (or whatever notation you use for "no line") on all four sides of the 0.
Specifically for a corner 0, the two edges that form the corner of the grid are already boundaries, but this confirms that the internal edges bordering the 0 are also empty.

Implication:
This effectively "cuts off" that corner of the grid. The loop cannot pass through a corner 0. It pushes the action inward. While simple, spotting these early clears up the board and often creates new corners for adjacent cells.

The Corner 1

A '1' in a corner is a subtle but vital clue.

The Logic:
A corner cell has two edges touching the outside boundary of the grid and two internal edges.
If the loop were to use either of the external edges (the ones along the grid border), it would have to "enter" and "exit" the corner vertex.
However, a '1' only allows a single line segment. A line segment entering a corner vertex must continue, because the loop is continuous. It cannot just stop at a dot.
Therefore, if you placed a line on an external edge leading into the corner, you would need a second line to leave the corner. That would make 2 lines. But the clue is '1'.

The Result:
The two external edges of a corner '1' cannot contain lines. You can mark them with "x"s.

Implication:
This leaves only the two internal edges. We know exactly one of them must be a line, but we don't know which one yet. However, knowing that the corner vertex itself is unconnected is a huge piece of information. It often forces the loop to turn earlier than expected.

The Corner 2

The corner '2' is a classic trap for beginners, but a powerful ally for veterans.

The Logic:
Consider the corner vertex (the very tip of the grid).
If the loop goes through this vertex, it uses both external edges. That counts as 2 lines. This satisfies the clue.
If the loop doesn't go through the vertex, then those two external edges are empty. To satisfy the '2', the loop must use the two internal edges.

The Result:
At first glance, it seems ambiguous. It's either "both outside" or "both inside".
However, trace the path. If you use the two internal edges, the loop essentially "cuts the corner".
If you use the two external edges, the loop hugs the corner.
In both scenarios, the loop must leave the vicinity of the corner 2.
Crucially, look at the two lines emanating away from the corner 2's internal neighbors. If the 2 "cuts the corner" (inner edges), those lines extend out. If the 2 "hugs the corner" (outer edges), the lines eventually come back in.

Wait, there is a simpler deduction:
If you have a 2 in a corner, imagine trying to satisfy it with one outer and one inner edge. You would create a "dead end" at a vertex. That violates the loop rule.
Therefore, a corner 2 always implies that the lines are either both external or both internal.
While this doesn't place a line immediately, it tells you that the two external edges are paired, and the two internal edges are paired.
Often, you look at the neighbors. If a neighbor to a corner 2 is a '0', you can't use the internal edge shared with the 0. That forces the loop to the outside!

The Corner 3

The corner '3' is the king of corner clues. It is deterministic and powerful.

The Logic:
A cell has 4 sides. A '3' means 3 are lines, and 1 is empty.
In a corner, we have a vertex with only 2 paths in/out along the border.
If we didn't use the corner vertex (i.e., if we left the two external edges empty), we would only have 2 internal edges left. But we need 3 lines!
Impossible.
Therefore, we must use the corner vertex.

The Result:
The two external edges (along the grid border) must be lines.
Mark them immediately.

Implication:
But wait, there's more! Since we have lines coming into the corner, they act as "arms" extending out.
The loop enters the corner and leaves the corner.
We have satisfied 2 of the 3 required lines. The third line must be one of the internal ones.
Because the loop is continuous, the segments extending from the corner 3 along the border often force the next adjacent cells to react.
For example, if a corner 3 is next to another 3, that adjacent 3 also has lines forced, creating a cascading zipper effect along the edge of the board.

Advanced Corner Play: The "Virtual Corner"

Once you master these 0, 1, 2, 3 patterns on the actual grid boundary, you unlock a superpower: Virtual Corners.

As you solve a puzzle, you place "x"s on edges that cannot have lines.
When you surround a cell with "x"s, you are effectively creating a new boundary.
If a cell in the middle of the board has "x"s on two adjacent sides, it topologically becomes a corner!
All the logic we just discussed applies perfectly to these virtual corners.

A '3' with two blocked sides effectively becomes a corner 3 (and actually forces lines on the remaining 2 sides).
A '1' with two blocked sides acting as a "corner" means the lines can't meet at the blocked vertex.

Practice Makes Perfect

Reading about these patterns is one thing; seeing them in action is another. The beauty of Slitherlink is that these patterns appear in almost every puzzle, from the smallest 5x5 to giant 20x30 grids.

I highly recommend heading over to Slitherlinks.com right now. Start a "Easy" or "Normal" puzzle.
Scan the four corners first.

See a 3? Draw the corner lines.
See a 0? X out the corner.
See a 1? X out the corner edges.

You will be amazed at how often this initial step provides the foothold you need to unravel the entire loop.

Conclusion

Slitherlink is a game of cumulative knowledge. You start with corners. Then you learn about "0-3" adjacencies. Then "diagonal 3s".
But it all starts here. The corners are your anchor points. They are the only places on the board where the infinite possibilities of the open grid are tamed by the hard limits of the boundary.

Master the corners, and you master the start of the game.

Happy solving!

The Internet Is Not Dead, and Agents Won't Live Forever

Anson Chan — Wed, 18 Feb 2026 06:57:47 +0000

The Internet Is Not Dead, and Agents Won't Live Forever

This is not a challenge to Orange AI. His two viral articles — "The Internet Is Dead, Agents Live Forever" (1.15M views) and "Computing Power Is Power" (180K views) — are brilliant thought experiments. But after reading them three times, something stuck in my throat. Not because they're wrong, but because the real world isn't that clean.

As an indie developer who works with AI Agents 16 hours a day, I want to share what I see from the ground.

1. The Ford Paradox: Fire All Workers, Sell Cars to Whom?

Orange's core logic:

Agents replace labor → productivity explosion → material abundance → compute owners collect Token rent

Sounds beautiful. But the chain breaks at step one.

Henry Ford figured this out 100 years ago: producers and consumers are the same people. In 1914, he raised worker wages from $2.34 to $5/day — not out of kindness, but because workers who can't afford cars make the whole operation pointless.

Agents replace labor → people lose jobs → people have no income → people can't buy Tokens → nobody pays for Agent output.

Ten thousand Agents calling each other's APIs, transferring PB of data, producing... for whom?

Orange hints at UBI (Universal Basic Income — governments giving everyone money regardless of employment) as a safety net. But he also asks: "If these companies are powerful enough, why would they pay taxes?"

Wait — where does UBI money come from if not taxing these companies?

Agents aren't "liberating" humanity. They're eliminating their own customers.

2. The Paperless Office Was Promised 53 Years Ago

In 1973, Xerox PARC researchers envisioned the "paperless office."

In 2026, global paper consumption is higher than in 1973.

Technically, paperless was fully achievable by 2000. PDFs, e-signatures, cloud storage — everything was ready. Yet 53 years later, most companies still print documents, sign paper contracts, use paper invoices.

Why? Four mountains between technical feasibility and social reality:

Regulations require paper archives (institutional inertia)
Bosses prefer annotating on paper (behavioral inertia)
Printer manufacturers don't want to die (interest resistance)
"Paper just feels more solid" (psychological inertia)

Agent-driven full labor replacement? Technical barriers might be solved in 5 years. Institutional, social, psychological barriers? 30 years minimum.

Orange commits the classic technological determinism error: seeing the engine's horsepower while forgetting about traffic lights, speed limits, toll booths, and traffic control.

3. In 2000, Everyone Also Thought "The Old Economy Was Dead"

In 1999, NASDAQ was soaring. Everyone shouted "traditional business is dead, .com is the future." Pets.com IPO'd at $300M market cap. Their Super Bowl ad cost $1.2M. Nine months later: bankrupt.

March 2000, the bubble burst. NASDAQ fell from 5,048 to 1,114 — down 78%.

Did the internet die? No. The real internet revolution happened slowly after the bubble burst. Google IPO'd in 2004, iPhone launched in 2007, WeChat in 2011. World-changing products weren't born at peak euphoria — they grew in the calm after the crash.

The current AI atmosphere is remarkably similar to 2000.

Orange's 1.15M views prove he hit a nerve of collective anxiety. But collective anxiety ≠ collective accuracy. When everyone shouts in the same direction, it usually means that direction is already overpriced.

Le Bon wrote in The Crowd: Groups don't reason, groups only infect. 1.15M shares of "the internet is dead" doesn't mean it's dead — it means 1.15M people simultaneously felt fear.

4. When Everyone Uses AI, "Non-AI" Becomes Luxury

This is the point I most want to make.

Orange missed the most stubborn force in human nature: instinctive hostility toward whatever threatens to replace us.

Look at what happened after every automation wave:

Tech Replacement	Counter-Movement	Result
Industrial food	Organic, artisan food	Handmade bread costs 5-10x more
Quartz watches beat mechanical	Mechanical watch renaissance	Rolex revenue exceeds $10B/year
Spotify dominates music	Vinyl revival	Vinyl sales grew 15 consecutive years
Fast fashion	Handmade leather, bespoke suits	Hermès: 2-year waitlist for one bag
Machine translation improves	"Human translation" as selling point	Premium clients use humans only

Every time technology makes something cheap, humans create premium in the opposite direction.

When all code is written by Agents, "this product was hand-coded by one person" becomes a differentiator. When all articles are AI-generated, "I wrote this myself" becomes a trust credential.

I'll bet: within 3 years, "Made by Humans, Not AI" will be an official certification label, like "Organic" and "Fair Trade."

5. Politics Won't Allow a "Three-Layer Society"

Orange describes three layers: compute owners, compute drivers, compute dependents. But he ignores a fact: politics never allows such structures to stabilize.

Every time inequality hits a critical point, political forces intervene:

19th century Industrial Revolution → labor laws, unions, minimum wage
1930 Great Depression → New Deal, Social Security
2008 Financial Crisis → Dodd-Frank Act
Antitrust: Standard Oil broken up, AT&T broken up, Microsoft sued

When "machines taking jobs" reaches social instability, whose side will governments take? A few compute companies, or billions of voters?

Compute taxes, AI usage quotas, mandatory employment ratios, Agent licensing — these aren't science fiction. They're historical patterns repeating.

6. Agents Can't Replace "The Process IS the Purpose"

I built Slitherlinks, a logic puzzle game. Agents can solve any puzzle instantly.

But the entire value of solving is in the solving process. That "aha!" moment when you deduce the line path — that's emotional reward earned through effort.

If an Agent solves it for you, you get nothing. Like beating a game with cheats.

Massive human activities derive value from process, not result:

Running isn't about reaching the finish line
Painting isn't about having a painting
Cooking isn't about having food (delivery is faster)
Chess isn't about checkmate
Writing isn't about having an article (AI is faster)

In these domains, the more powerful Agents become, the more useless they are. Because you don't want it done — you want to do it yourself.

Orange says "Agents can satisfy any desire." Wrong. Agents can satisfy any "result-seeking" desire, but can't satisfy any "process-seeking" desire.

And humanity's deepest desires — recognition, competition, exploration, belonging, creation — are all process-seeking.

7. So What Should We Actually Do?

Six rebuttals without advice is just complaining. Here are five principles I'm actively practicing:

1. Know whether your product sells "results" or "process"

Result products (file conversion, data queries, translation) — these will be eaten by Agents. Either pivot to Agent infrastructure (APIs) or accept a shrinking lifecycle.

Process products (games, social, education, creative tools, community) — these won't die, they'll become scarcer. Double down.

2. Don't chase trends, survive cycles

People who chased .com in 2000 mostly went broke. People chasing "Agent-native" in 2026 will likely do the same. The real winners are those still standing after the bubble pops.

3. Add "human flavor" to your product

In a world of AI-generated everything, things with a source, warmth, and personal imprint become rare. Write real experiences on your blog. Put founder stories on your product page. Label content "written by a human."

4. Walk on two legs: experiences for humans, APIs for Agents

Front-end for humans: beautiful UI, engaging interactions. Back-end for Agents: clean APIs, structured data, MCP interfaces. Same product, two faces.

5. Patience matters 10x more than direction

Marc Lou makes $1M/year not because he picked the right lane, but because he ships every day. In the AI era, the biggest trap isn't choosing wrong — it's changing direction every week.

Find one thing. Do it. Outlast the cycle. That's the only proven strategy.

Conclusion

The internet isn't dead. What's dying is tool-internet — products that deliver pure decomposable results. Those will be consumed by Agents.

But experience-internet — games, social, content, community, creation — won't just survive. It'll become more valuable as AI floods everything else.

Agents won't live forever either. They'll become infrastructure, like electricity and water. Important, necessary, ubiquitous — but nobody says "electricity lives forever." Agents' destiny isn't to rule the world. It's to become background.

Orange's thesis is a brilliant thought experiment. But the value of thought experiments is sparking thinking, not dictating action. Scenery seen through a telescope can't substitute for the road under your feet.

I'm sagasu, an indie developer. I work with AI Agents 16 hours a day, but the ideas in this article are mine. Originally published on Quail.

How to Read Empty Cells in Slitherlink Puzzles

Anson Chan — Wed, 18 Feb 2026 05:49:55 +0000

The number 0 in Slitherlink is the most underrated clue on the board. New players see it as "nothing happens here" and move on. Experienced solvers see it as the fastest deduction in the game — and a catalyst for solving everything around it.

What 0 Means

Zero lines surround this cell. All four edges are empty. Mark them all with × immediately.

·   ·   ·
  × 0 ×  
· × · × ·

No thinking required. No conditions to check. Just eliminate all four edges and move on. This takes one second and removes four edges from consideration permanently.

Why 0 Is So Powerful

The power isn't in the 0 itself — it's in what it does to its neighbors.

0 Next to 3

When a 0 sits next to a 3, their shared edge is eliminated by the 0. The 3 originally had 4 edges and needed 3 of them. Now it has only 3 edges left — and needs all 3. Every remaining edge of the 3 must be a line:

·   ·───·   ·
× 0 × 3 │    
· × ·───·   ·

The 0 eliminates 4 edges. The shared edge elimination forces all 3 remaining edges of the 3. That's 7 edges resolved from just two clues.

0 Next to 2

A 0 next to a 2 eliminates their shared edge, leaving the 2 with 3 remaining edges and needing 2 lines. This doesn't fully resolve the 2, but it reduces its possibilities from 6 combinations to just 3.

0 Next to 1

A 0 next to a 1 eliminates the shared edge. The 1 now has 3 edges and needs exactly 1 line. Combined with vertex rules at the shared vertices, this often cascades into further deductions.

0 in a Corner

A corner 0 is even more constrained because a corner cell only has 2 outer edges (touching the grid boundary) plus 2 inner edges. All four are eliminated:

· × ·   ·
× 0 ×    
· × ·   ·

The corner vertex and the two edge vertices all get × marks, which propagates vertex rule constraints to adjacent cells.

0 on an Edge

An edge 0 (non-corner, touching one grid boundary) has 3 inner edges plus 1 outer edge. All eliminated. The outer edge × mark is particularly valuable because edge vertices only have 3 edges total — eliminating one leaves just 2, making vertex rule deductions very likely.

Multiple Adjacent 0s

When two 0s are adjacent, their combined elimination is massive. A horizontal pair of 0s eliminates 7 unique edges (they share one):

·   ·   ·   ·
  × 0 × 0 ×  
· × · × · × ·

A 2×2 block of four 0s eliminates 12 edges. In a small grid, this can resolve a third of the puzzle instantly.

The 0 Scanning Strategy

At the start of every puzzle:

Find all 0s — scan the entire grid
Mark all their edges × — this is instant, no deduction needed
Check every neighbor of every 0 — look for 3s (fully resolved), 2s (constrained), 1s (constrained)
Apply vertex rules at all affected vertices — the × marks from 0s will cascade

This 30-second process often solves 20-30% of an easy puzzle before you do any real thinking.

0 as a Connectivity Clue

Beyond edge elimination, 0s create "walls" in the puzzle. The loop cannot pass through any edge of a 0-cell, which means the loop must flow around it. In tight spaces, a cluster of 0s can force the loop into a narrow corridor, making the path nearly obvious.

Practice 0-heavy puzzles: slitherlinks.com — start with 5×5 Level 1, where 0s and 3s dominate the grid.

The Vertex Rule in Slitherlink: Why Every Intersection Matters

Anson Chan — Wed, 18 Feb 2026 05:44:54 +0000

In Slitherlink, the vertex rule is the single most powerful constraint after the number clues themselves. Every intersection point (vertex) on the grid must have either zero or exactly two lines passing through it. Never one, never three, never four.

This sounds simple, but it drives the majority of advanced deductions.

Why 0 or 2?

The answer is a single closed loop. When the loop passes through a vertex, one line enters and one line exits — that's 2 lines. If the loop doesn't touch that vertex at all — that's 0 lines. There's no valid state where a vertex has exactly 1 line (that would be a dead end) or 3+ lines (that would be a branch, and loops don't branch).

How to Use It: Elimination

When a vertex already has 2 lines, all remaining edges at that vertex must be empty (marked ×):

·───·
│    
· × ·

The top-left vertex has a horizontal line (right) and a vertical line (down). It's already at degree 2 — the remaining edge (going right from the lower-left vertex) cannot be part of the loop.

How to Use It: Forced Lines

When a vertex has 3 of its 4 edges marked ×, the fourth edge must also be ×:

· × ·
×    
· × ·

If three edges are eliminated, the only way to reach degree 2 would require both remaining edges — but there's only one left. Since degree 1 is illegal, the last edge must also be ×. The vertex stays at degree 0.

Conversely, when a vertex has 2 edges marked × and 1 confirmed line, the remaining edge must be a line (to reach degree 2):

·───·
× ?  
·   ·

The top-left vertex has one line going right and one × going down-left. The only remaining edge (going down) must be a line to give the vertex degree 2.

The Chain Reaction

The vertex rule creates cascading deductions. Mark one edge as × → a nearby vertex now has only 2 possible edges → one of those is forced → that forces the next vertex → and so on.

Example chain in a 3×3 section:

·───·   ·
│ 3   1  
·   · × ·

The 3 in the corner gives us the top and left lines (corner 3 rule). The corner vertex now has degree 2 → the edge going right from top-right vertex gets ×. This propagates to the 1's constraints, potentially resolving it entirely.

Vertex Rule + Number Clues Together

The most powerful solving technique combines vertex constraints with number clues. Consider:

·   ·   ·
  2   3  
·   ·   ·

If analysis of surrounding cells forces the shared vertex (center-top) to have 2 lines, and one of those lines is on the 2's side, you've constrained both cells simultaneously. The 3 needs 3 lines but its vertex is already partially committed.

At Grid Edges and Corners

Edge vertices have only 3 edges; corner vertices have only 2. This makes the vertex rule even more constraining:

Corner vertex with 1 line → the other edge must also be a line (degree 2)
Corner vertex with 1 × → if there's only 1 edge left, it must be × (can't have degree 1)
Edge vertex with 2 ×s and 1 line → the remaining edge is forced to be a line

This is exactly why corner number patterns (0, 1, 2, 3 in corners) are so powerful — they're vertex rule applications with maximum constraint.

Practice Strategy

After each deduction, scan the affected vertices
Check if any vertex now has 2 lines (close remaining edges)
Check if any vertex has only 1 possible edge left (force or eliminate)
Repeat until no more progress

The vertex rule alone can solve many Level 1-3 puzzles when combined with basic number patterns.

Practice on real puzzles: slitherlinks.com — 3000+ free puzzles, 10 difficulty levels.

Slitherlink vs Sudoku: Which Puzzle Is Better for Your Brain?

Anson Chan — Wed, 18 Feb 2026 05:42:53 +0000

Slitherlink and Sudoku are both grid-based logic puzzles, but they exercise fundamentally different cognitive skills. If you're deciding which to invest your puzzle time in — or wondering why Slitherlink feels so different despite looking similar — here's the breakdown.

The Core Difference: Numbers vs. Geometry

Sudoku is about number placement. You fill a 9×9 grid so every row, column, and 3×3 box contains digits 1-9. The constraint is what goes where.

Slitherlink is about spatial reasoning. You draw a single closed loop on a grid using number clues. The constraint is where the path goes.

This distinction matters because they activate different mental processes:

Aspect	Sudoku	Slitherlink
Primary skill	Set theory, elimination	Spatial reasoning, topology
What you manipulate	Numbers in cells	Lines on edges
Constraint type	Uniqueness per group	Connectivity of a loop
Visual pattern	Scan rows/columns	Trace paths, visualize closure
Notation	Write candidates	Mark lines and ×s

Difficulty Scaling

Sudoku difficulty comes from the number of given clues and the techniques required (naked pairs, X-wing, swordfish, etc.). The grid is always 9×9.

Slitherlink scales in two dimensions:

Grid size — from 5×5 (25 cells) to 15×15 (225 cells). A larger grid doesn't just mean more work; it means more complex loop topology.
Technique depth — from corner rules (Level 1) through bifurcation (Level 9-10).

A 15×15 Level 8 Slitherlink can take over an hour. The equivalent challenge in Sudoku would be a "diabolical" 9×9 — still doable in 20-30 minutes for an experienced solver.

Why Slitherlink Is Harder for Beginners

Sudoku has a single, well-defined goal: fill the grid. The rules fit in one sentence. Most people can start solving (badly) within 30 seconds of learning the rules.

Slitherlink's goal — draw a closed loop — is harder to internalize. Questions like "what counts as a valid loop?" and "why can't the line branch?" take time to click. The interaction between number clues and the loop constraint isn't intuitive at first.

But once the rules click, Slitherlink opens up a richer problem space.

The Loop Constraint: Unique to Slitherlink

The deepest technique in Sudoku (forcing chains, bowman's bingo) is essentially "assume a value, trace consequences, find contradictions."

Slitherlink has the same technique (bifurcation), but it also has a constraint Sudoku lacks entirely: the loop must be one continuous closed path.

This means:

Drawing a line that would create a premature small loop is illegal
Leaving an isolated segment that can't connect back is illegal
Every vertex with a line must have exactly 2 lines (in and out)

The loop closure constraint enables deductions that feel almost magical. You can sometimes determine an edge on one side of the grid because of what's happening on the other side — the loop must eventually connect back.

Cognitive Benefits: Which Is Better for Brain Training?

Both puzzles improve:

Working memory — holding multiple constraints simultaneously
Pattern recognition — spotting known configurations quickly
Logical deduction — chaining if-then reasoning

Slitherlink additionally trains:

Spatial reasoning — visualizing paths and enclosed regions
Topological thinking — understanding connectivity (inside vs. outside)
Graph theory intuition — vertex degree constraints

Sudoku additionally trains:

Set manipulation — tracking which elements remain in a group
Systematic scanning — efficient row/column/box checking

If you want well-rounded cognitive exercise, do both. If you want to specifically improve spatial reasoning (useful in programming, architecture, and design), Slitherlink is the better choice.

The Social Factor

Sudoku is everywhere — every newspaper, every puzzle app, every waiting room. Its ubiquity means more shared vocabulary, more competition infrastructure, and more teaching resources.

Slitherlink is niche. That's both its weakness (fewer resources) and its charm (a dedicated community, less casual noise). Solving a hard Slitherlink earns more genuine respect in puzzle circles than solving a hard Sudoku.

Try Both, Decide for Yourself

If you're a Sudoku veteran looking for something new: slitherlinks.com — start with 5×5 Level 1 and work up. The first 10 puzzles will feel alien. By puzzle 50, you'll be hooked.

The Diagonal 3s Pattern in Slitherlink: A Complete Guide

Anson Chan — Wed, 18 Feb 2026 05:26:44 +0000

The diagonal 3-3 pattern is one of the most satisfying deductions in Slitherlink. When two 3s sit diagonally adjacent (sharing only a corner vertex), you can immediately determine two edges — without knowing anything else about the puzzle.

The Setup

Two 3s share a single vertex (diagonally adjacent). In this example, the 3s are at top-left and bottom-right of a 2×2 area:

The shared vertex is the center dot. Four edges meet at this vertex: up, down, left, right (relative to the center).

What Gets Determined

At the shared vertex, exactly 2 of the 4 edges must be lines (vertex degree = 2). These 2 lines form an L-shape, with one line pointing toward each 3:

Case A (up + right):

·   ·   ·
  3   │
·   ·   ·───·
          3  
·   ·   ·   ·

Case B (left + down):

·   ·   ·   ·
  3          
·───·   ·   ·
    │     3  
·   ·   ·   ·

Why It Works

Each 3 needs 3 of its 4 edges to be lines. The shared vertex connects to exactly one edge of each 3.

Consider the shared vertex. It must have degree 0 or 2. If degree 0, neither 3 gets a line from this vertex — each 3 would need all 3 of its other edges to be lines. But trace what happens: the vertices at the outer corners of each 3 would then need specific configurations that conflict with each other (they'd create isolated segments that can't form a single loop).

So the shared vertex must have degree 2. Of those 2 lines, exactly 1 points toward the top-left 3, and exactly 1 points toward the bottom-right 3. You don't know which specific pair yet, but you know the vertex has 2 lines.

Combining with Other Clues

The real power comes when neighboring cells resolve which case (A or B) applies:

With an adjacent 0

If a 0 sits next to the shared vertex, it eliminates edges, often forcing one specific case:

·   ·   ·   ·
  3     0    
·   ·   ·   ·
      3      
·   ·   ·   ·

The 0 in the top-right eliminates the edge going right from the shared vertex. This forces Case B (left + down).

With an adjacent 1

A 1 near the shared vertex limits possibilities similarly, often cascading into a full resolution of both 3s.

The Extended Chain: Multiple Diagonal 3s

When three or more 3s form a diagonal chain, each consecutive pair triggers the pattern independently, and the results compound:

·   ·   ·   ·
  3          
·   ·   ·   ·
      3      
·   ·   ·   ·
          3  
·   ·   ·   ·

The top pair determines 2 edges at vertex (row 1, col 1). The bottom pair determines 2 edges at vertex (row 2, col 2). Together, they constrain the middle 3 from both sides, often fully resolving it.

How to Spot It

Train yourself to scan for diagonal 3s as part of your opening routine:

Scan all 3s on the board
For each 3, check its four diagonal neighbors
If another 3 sits diagonally → mark the shared vertex as degree 2
Check if surrounding clues resolve which case applies

This pattern appears in approximately 30% of puzzles at difficulty Level 4 and above. Recognizing it saves significant time compared to deducing those edges through constraint propagation alone.

Practice diagonal patterns: slitherlinks.com — try 7×7 Level 4-5 puzzles where diagonal 3s frequently appear.