I’ve always loved Simon Tatham’s puzzle collection — especially Bridges, Slitherlink, and Signpost. I’ve been playing them for years on desktop and Android.

Recently I decided to port the collection to iOS with a more modern native UI and some usability improvements, while keeping the original puzzle generation logic intact.

The core puzzle engines are still Simon’s original C implementations. I built a thin Swift layer around them and focused mostly on:

Native SwiftUI interface

Better touch interactions

Dark mode

Offline support

Fast puzzle generation

Clean, minimal UI (no ads)

A few technical notes:

The puzzle logic runs as compiled C modules bridged into Swift

Puzzle state is serialized/deserialized to allow undo/redo

I implemented a custom rendering layer to support dynamic grid scaling

All puzzles are generated locally (no backend)

One thing I found interesting is how well the original C codebase is structured — it’s surprisingly modular for something that supports so many puzzle types.

I tried to stay faithful to the original mechanics while improving the mobile UX.

Would love feedback, especially from anyone familiar with the original project or who has thoughts on puzzle UI design.

App link: https://apps.apple.com/us/app/simon-puzzles/id6756353841

Thanks Simon for building such a timeless collection.

I have also built games using Cursor, and I have to say that the current AI is really strong.

https://puzzles-game.com/

The rules of the game are simple: jump over a piece to remove the jumped piece. Try to remove all pieces except one. Drag a piece to an empty space to move it. The target position must be exactly two holes away from the starting piece, the directions must be orthogonal, and there must be a piece in the middle hole. But I always end up with a few pieces that are far apart and can't be solved. What's the idea of playing this kind of game?

Comments URL: https://news.ycombinator.com/item?id=44315613

Points: 2

# Comments: 1

Through source code analysis, it reveals how LevelDB achieves 400,000 writes per second throughput through core technologies like WriteBatch merging strategy, dual MemTable memory management, WAL sequential write optimization, and dynamic Level0 file throttling.

It also explores engineering details such as mixed sync write handling, small key-value merge optimization, and data consistency in exceptional scenarios, helping you master the design essence and implementation strategies of LevelDB's high-performance writing.

There are many reasons why a C++ process might coredump, including:

Illegal Memory Access: This includes dereferencing null pointers, accessing freed memory, array bounds violations, etc. Stack Overflow: Caused by infinite recursion or large arrays allocated on the stack Segmentation Fault: Attempting to write to read-only memory or accessing unmapped memory regions Uncaught Exceptions: Program termination due to unhandled exceptions When encountering a coredump, we typically need to examine the core file for problem analysis and debugging. Analyzing core files can be challenging as it requires a deep understanding of C++’s memory model, exception handling mechanisms, and system calls.

Rather than focusing on core file analysis methods, this article will present several real-world cases to help developers proactively avoid these errors in their code.

This Minesweeper game offers two game modes:

- *Classic Mode*: Traditional square grid minesweeper, identical to the one bundled with Windows. Each square is adjacent to eight neighboring squares (horizontally, vertically, and diagonally). - *Hexagonal Mode*: An innovative hexagonal grid minesweeper where each cell is a regular hexagon adjacent to six neighboring cells. This mode offers a fresh gaming experience, requiring players to adapt to new spatial relationships for logical deduction.

Previously, when having Claude write code, I used well-known libraries with detailed documentation. AI models were already trained on these libraries, making it easy to write code.

However, this time, I used a [relatively obscure maze generation library](https://github.com/codebox/mazes) without documentation. Since the AI model had no knowledge of this library, getting AI to use it for my task was challenging.

It has many difficult levels built in, and also supports custom levels to share with friends.

Welcome to challenge！

So I thought about implementing one using Claude3.5, but the process wasn't smooth, and I encountered quite a few pitfalls along the way. I started working on it in July, trying intermittently multiple times, until recently when I finally managed to implement a simple version. This article records the process of implementing this tool using Claude3.5 and documents the pitfalls encountered along the way. You can experience the final result here, and feel free to leave comments for discussion.

This article starts by discussing the drawbacks of current binary search trees and balanced trees, introducing skip lists as a data structure. Then, based on the original paper, it explains the implementation principles of skip lists, followed by a detailed analysis of LevelDB's implementation code, including iterator implementation and extreme performance optimization for concurrent reading.

Finally, it provides a visualization page that intuitively shows the skip list construction process.