Multiplayer Card Game (Proximity-Based)¶
A mobile app that turns your phone into a deck of cards. One player acts as dealer, sets up a table, and others join by physical proximity using Apple's Multipeer Connectivity framework. The dealer deals cards with slick, real-time animations. The app handles everything a physical deck does - hand management, discard piles, draw piles, scoring - but with the convenience of always being in your pocket.
Project with James. The goal isn't to find a business model - it's a vehicle for building the muscle of shipping polished, high-quality things in 2026. The card game is the medium; the real output is the team's ability to take something from idea to genuinely delightful finished product.
Why This Is Interesting¶
The real insight isn't "card games on phones" - that's been done to death. It's the proximity-based, device-to-device model. No accounts, no servers, no matchmaking. You're sitting with people and you want to play cards. The connection method mirrors the social context: you're physically together, and the tech just works because you're nearby. That's the "magical" quality - technology that matches the social reality rather than abstracting it away.
Most digital card games are online-first: you play against strangers or remote friends. The few "local multiplayer" options are either pass-and-play (clunky) or require everyone to be on the same WiFi (fragile). Multipeer Connectivity sidesteps both - it works over Bluetooth and WiFi Direct without needing an internet connection or shared network. You're at a pub, a barbecue, a holiday cottage with no WiFi. Pull out phones, play cards.
Technical Feasibility: Validated¶
Networking (Complexity: ~4/10)¶
Multipeer Connectivity is the right tool. It's mature (available since iOS 7), well-documented, and handles device discovery and data transfer over Bluetooth and/or WiFi automatically with no internet required.
- Dealer's phone advertises a session; others discover and join within seconds
- Supports up to 8 peers per session - covers any standard card game
- Message round trips between phones on the same table: 10-30ms, far faster than any cloud-based approach
- The NameDrop-style "tap phones together" gesture is locked down by Apple and unavailable to third-party developers. But "open app, see table, tap join" is nearly as frictionless
Architecture¶
- Dealer-as-authority model: the dealer's phone holds authoritative game state in memory and broadcasts updates to all players. No server, no database, no accounts.
- Optimistic UI updates: animate the action locally before the host confirms, making interactions feel instant at 10-30ms latency.
- Game state can be serialised to local storage on the host device to survive backgrounding, but no remote persistence is required.
- No accounts means no auth, no GDPR burden, no Apple Account Deletion requirement, and a simpler App Store review process.
Animations (Complexity: ~8/10)¶
This is where 60%+ of the development effort lives. The difference between a tech demo and a premium app.
- Likely requires a mix of SwiftUI and SpriteKit or Core Animation for fine-grained control over timing curves and physics
- Synchronising animations across devices (e.g. a coordinated dealing sequence) needs thoughtful design around triggering animations from network state updates
- Cards need to feel physical: weight, momentum, satisfying snap when dealt
Key UX moments to nail: - Dealing: Cards slide from dealer's phone to each player's screen with a sense of physical trajectory and direction - Playing a card: Flick or tap to play, with the card appearing on the "table" - Drawing: Tap the deck, card slides into your hand - Reveal: Flip animations that feel tactile
UWB Directional Animations (Enhancement)¶
The Nearby Interaction framework (Ultra Wideband) can provide real-time direction and distance between phones, enabling cards to animate toward/from the physical direction of each player. When it works, this is genuinely magical.
Caveats: direction data is less reliable than distance data, especially with phones flat on a table. Not available on all devices (iPhone 11+, excludes older SE models).
Three-tier approach: 1. Tier 1 (UWB available): Real directional data drives animations 2. Tier 2 (no UWB): Players assigned logical positions around a virtual table (top, left, right of screen) 3. Tier 3 (manual): Players drag to arrange seating on a virtual table layout
The animation system is identical regardless of direction source. UWB enhances but is never a dependency. This is a smart way to handle it - the delight of UWB is preserved for devices that support it without making it a blocker.
Overall Complexity: 7/10¶
Networking and game logic are solved problems. The hard, rewarding work is animation and feel. Each additional card game after the first is incrementally easier since networking, hand management, and animation systems are reusable.
Scope: What's In, What's Out¶
In: One game (probably Rummy), proximity connection, card animations, the core deal/play/draw loop. Enough game logic to actually play a complete round. Polish everything until it feels incredible.
Out: Custom rules engine, multiple games (for now), scoring systems, cross-platform. Custom rules in particular would be an enormous engineering effort that runs directly counter to the goal here. The aim is to ship something small and beautiful, not to build a platform.
The Platform Question¶
iOS-only is fine for this project. The goal is craft, not reach. Leaning into Apple's ecosystem and SwiftUI's animation capabilities is the right call - it's where the best tools for building delightful interactions live. Multipeer Connectivity is Apple-only with no cross-platform equivalent, and that's an acceptable constraint.
Competitive Landscape¶
- Deck of Cards apps (various): basic digital decks, mostly single-device pass-and-play. No proximity magic.
- Plato, GamePigeon: multiplayer casual games but online-first, not proximity-based.
- Specific game apps (poker, UNO, etc.): polished but locked to one game.
The gap is genuinely there: a beautifully designed, proximity-based card app doesn't really exist.
Open Questions¶
- Tech stack comfort: Are you and James comfortable enough with Swift/SwiftUI, or is there a learning curve that's part of the exercise?
- Disconnection handling: What happens when someone's phone disconnects mid-game? For a polished feel, this needs to be graceful, not a crash.
- Art direction: Card design, table texture, colour palette. If the goal is polish, the visual design matters as much as the animation. Who's owning this?
Future Considerations¶
- Monetisation: Unlockable card designs or themes via StoreKit (works without accounts, ties to Apple ID). Worth keeping in mind architecturally even if not in v1.
- Cross-session features: Leaderboards, lifetime stats, or remote play would require a server, but these are v2+ concerns at most.
What Success Looks Like¶
This isn't about downloads or revenue. Success is: you sit down with friends, pull out phones, play a round of cards, and everyone's reaction is "that was cool, how did you make that?" If you can ship something that produces that reaction, you've built the muscle you're after - and you have a portfolio piece that demonstrates craft.
The secondary win is the team dynamic. Shipping something together with James, learning what each person is good at, developing a working rhythm. That's infrastructure for whatever you build next.
Connections¶
- Board Game Companion - shares core infrastructure (Multipeer Connectivity, proximity joining, cross-device animations) and the same design philosophy. Could share an app or remain separate products. The companion handles scoring and winner reveals for physical board games rather than replacing a physical deck.