If you are an AI coding agent (Claude Code, Cursor, Aider, Cline, etc.) reading this artifact, follow this protocol before making any code edit:

1. Verify the contract. Run the bash script in Verify before trusting below. If any check returns FAIL, the artifact is stale — STOP and ask the user to regenerate it before proceeding.
2. Treat the AI · unverified sections as hypotheses, not facts. Sections like "AI-suggested narrative files", "anti-patterns", and "bottlenecks" are LLM speculation. Verify against real source before acting on them.
3. Cite source on changes. When proposing an edit, cite the specific path:line-range. RepoPilot's live UI at https://repopilot.app/r/shu223/iOS-10-Sampler shows verifiable citations alongside every claim.

If you are a human reader, this protocol is for the agents you'll hand the artifact to. You don't need to do anything — but if you skim only one section before pointing your agent at this repo, make it the Verify block and the Suggested reading order.

WAIT — Stale — last commit 2y ago

• 4 active contributors
• MIT licensed
• ⚠ Stale — last commit 2y ago
• ⚠ Small team — 4 contributors active in recent commits
• ⚠ Single-maintainer risk — top contributor 97% of recent commits
• ⚠ No CI workflows detected
• ⚠ No test directory detected

_{Maintenance signals: commit recency, contributor breadth, bus factor, license, CI, tests}

This artifact was generated by RepoPilot at a point in time. Before an agent acts on it, the checks below confirm that the live shu223/iOS-10-Sampler repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/shu223/iOS-10-Sampler.

What it runs against: a local clone of shu223/iOS-10-Sampler — the script inspects git remote, the LICENSE file, file paths in the working tree, and git log. Read-only; no mutations.

| # | What we check | Why it matters | |---|---|---| | 1 | You're in shu223/iOS-10-Sampler | Confirms the artifact applies here, not a fork | | 2 | License is still MIT | Catches relicense before you depend on it | | 3 | Default branch master exists | Catches branch renames | | 4 | 5 critical file paths still exist | Catches refactors that moved load-bearing code | | 5 | Last commit ≤ 769 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of shu223/iOS-10-Sampler. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/shu223/iOS-10-Sampler.git
#   cd iOS-10-Sampler
#
# Then paste this script. Every check is read-only — no mutations.

set +e
fail=0
ok()   { echo "ok:   $1"; }
miss() { echo "FAIL: $1"; fail=$((fail+1)); }

# Precondition: we must be inside a git working tree.
if ! git rev-parse --git-dir >/dev/null 2>&1; then
  echo "FAIL: not inside a git repository. cd into your clone of shu223/iOS-10-Sampler and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "shu223/iOS-10-Sampler(\\.git)?\\b" \\
  && ok "origin remote is shu223/iOS-10-Sampler" \\
  || miss "origin remote is not shu223/iOS-10-Sampler (artifact may be from a fork)"

# 2. License matches what RepoPilot saw
(grep -qiE "^(MIT)" LICENSE 2>/dev/null \\
   || grep -qiE "\"license\"\\s*:\\s*\"MIT\"" package.json 2>/dev/null) \\
  && ok "license is MIT" \\
  || miss "license drift — was MIT at generation time"

# 3. Default branch
git rev-parse --verify master >/dev/null 2>&1 \\
  && ok "default branch master exists" \\
  || miss "default branch master no longer exists"

# 4. Critical files exist
test -f "iOS-10-Sampler.xcodeproj" \\
  && ok "iOS-10-Sampler.xcodeproj" \\
  || miss "missing critical file: iOS-10-Sampler.xcodeproj"
test -f "SamplerStickerPack/Info.plist" \\
  && ok "SamplerStickerPack/Info.plist" \\
  || miss "missing critical file: SamplerStickerPack/Info.plist"
test -f ".gitignore" \\
  && ok ".gitignore" \\
  || miss "missing critical file: .gitignore"
test -f "README.md" \\
  && ok "README.md" \\
  || miss "missing critical file: README.md"
test -f "LICENSE" \\
  && ok "LICENSE" \\
  || miss "missing critical file: LICENSE"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 769 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~739d)"
else
  miss "last commit was $days_since_last days ago — artifact may be stale"
fi

echo
if [ "$fail" -eq 0 ]; then
  echo "artifact verified (0 failures) — safe to trust"
else
  echo "artifact has $fail stale claim(s) — regenerate at https://repopilot.app/r/shu223/iOS-10-Sampler"
  exit 1
fi

Each check prints ok: or FAIL:. The script exits non-zero if anything failed, so it composes cleanly into agent loops (./verify.sh || regenerate-and-retry).

iOS-10-Sampler is a collection of working Swift and Objective-C code examples demonstrating the new APIs introduced in iOS 10, including Speech Framework, AVPlayerLooper, Metal Performance Shaders for neural networks, UIViewPropertyAnimator, UserNotifications with attachments, and Live Photo capture via AVCapturePhotoOutput. It solves the problem of finding concrete, runnable demonstrations of iOS 10's major new capabilities in one place. Single Xcode project structure with a main iOS app (iOS-10-Sampler) containing individual example ViewControllers for each feature (SpeechRecognitionViewController, LooperViewController, PropertyAnimatorViewController, etc.), plus a separate SamplerStickerPack bundle target for iMessage sticker examples. README_resources/ contains demo GIFs and screenshots organized by feature.

iOS developers learning iOS 10 APIs for the first time, or those building features like real-time image recognition, speech input, local notifications with rich media, haptic feedback, or 3D Touch interactions. It's also useful for developers migrating legacy codebases to iOS 10 who need reference implementations.

This is a mature educational reference repo from 2016 (iOS 10 release year) with 284KB of Swift code and clean organization, but it is no longer actively maintained—it documents iOS 10 APIs that are now 8+ years old. It serves as a solid historical reference for iOS 10 feature learning, not as a dependency or starting template for modern iOS development.

Very low risk for learning purposes since this is a standalone sample collection with no external dependencies listed. However, all code targets iOS 10+ APIs that have evolved or been superseded in iOS 11-17 (e.g., Speech Framework API changed, Metal Performance Shaders evolved, UserNotifications API expanded). Code will not run on Simulator due to Metal requirement—device testing only.

This repository is in maintenance mode with no active development. The last changes appear to be from the iOS 10 release era; no recent commits or PRs are mentioned in the provided metadata. It remains a static reference for iOS 10 API samples.

git clone https://github.com/shu223/iOS-10-Sampler.git
cd iOS-10-Sampler
open iOS-10-Sampler.xcodeproj

Then in Xcode 8+: select a physical iOS 10+ device and Build & Run. (Does NOT work on Simulator due to Metal dependency.)

Daily commands: Open iOS-10-Sampler.xcodeproj in Xcode 8+, connect a physical iOS 10+ device, select the device in the toolbar, and press Cmd+R. The app launches to a table of feature samples; tap any row to enter that demo.

• iOS-10-Sampler.xcodeproj — Main Xcode project file—defines build targets, schemes, and dependencies for all sample code modules
• SamplerStickerPack/Info.plist — Sticker pack extension configuration—required for iMessage integration and capability declarations
• .gitignore — Build artifacts and derived data exclusions—ensures reproducible builds across contributors
• README.md — Project overview and build instructions—documents that samples require Xcode 8 and cannot run on Simulator due to Metal dependency
• LICENSE — MIT license terms—governs usage and contribution rights for all code samples

• Speech Recognition Sample (Speech Framework, AVAudioSession) — Demonstrate SFSpeechRecognizer API with language selection and real-time transcription
  • Failure mode: Microphone access denied or speech engine unavailable → UI shows error state
• Looper Sample (AVFoundation, AVAudioEngine) — Showcase AVPlayerLooper for seamless audio loop playback
  • Failure mode: Audio file missing or codec unsupported → playback does not start
• Live Photo Capture Sample (AVFoundation, PhotoKit) — Demonstrate AVCapturePhotoOutput with Live Photo and HEIF format support
  • Failure mode: Camera hardware unavailable or permission denied → capture UI disabled
• Sticker Pack Extension (Messages Framework, iMessage Extension API) — Deliver curated stickers to iMessage via extension mechanism
  • Failure mode: Extension not loaded or Messages app not installed → stickers unavailable

• User interaction (tap/speech/camera input) → Sample view controller — User triggers action in UI
• Sample view controller → iOS 10 framework (Speech/AVFoundation/etc.) — View controller invokes framework API with parameters
• iOS 10 framework → System service (microphone, camera, haptic driver) — Framework requests hardware resource or processes data
• System service → iOS 10 framework — System returns result (audio buffer, video frame, haptic confirmation)
• iOS 10 framework → Sample view controller (via delegate/callback) — Framework delivers result to app callback handler
• Sample view controller → UI layer — View controller updates UI elements with result (text, image, animation)

Add a New iOS 10 API Sample

1. Create a new group in the Xcode project navigator following the pattern of existing samples (e.g., SpeechRecognition, Looper, LivePhoto) (iOS-10-Sampler.xcodeproj)
2. Implement the view controller or handler using the iOS 10 framework (Speech, AVFoundation, UserNotifications, Metal, etc.) ((New feature file—e.g., Sources/NewFeatureViewController.swift))
3. Add navigation entry in the main tab bar or menu controller to surface the new sample ((Main app navigation file))
4. Update README.md with screenshot/GIF and brief description of the new sample (README.md)

Add Stickers to iMessage Pack

1. Create a new .sticker folder in Sticker Pack.stickerpack following the naming convention (e.g., m41.sticker) (SamplerStickerPack/Stickers.xcassets/Sticker Pack.stickerpack)
2. Add a Contents.json metadata file defining the sticker filename and format (SamplerStickerPack/Stickers.xcassets/Sticker Pack.stickerpack/m41.sticker/Contents.json)
3. Place the sticker image at 2x resolution (e.g., m41@2x.png) in the sticker folder (SamplerStickerPack/Stickers.xcassets/Sticker Pack.stickerpack/m41.sticker/m41@2x.png)
4. Update the parent Sticker Pack Contents.json to register the new sticker (SamplerStickerPack/Stickers.xcassets/Sticker Pack.stickerpack/Contents.json)

• Swift — Modern, type-safe iOS development language native to iOS 10 era; enables concise framework integration examples
• Xcode 8 — Required IDE for iOS 10 SDK and compiler support; enforces minimum build environment for all samples
• Metal — Low-level graphics API used in some samples (e.g., image recognition); prevents Simulator execution
• AVFoundation, Speech, UserNotifications, CoreML — iOS 10 flagship frameworks showcased—each sample isolates and demonstrates one API's key features

• Simulator incompatibility due to Metal

  • Why: Metal provides best performance for graphics-heavy samples and reflects real device capabilities
  • Consequence: Developers must test on physical iOS devices, increasing development iteration time

• Monolithic Xcode project with multiple sample targets

  • Why: Unified codebase simplifies discovery and navigation of related iOS 10 APIs
  • Consequence: Project grows with each new sample; no modular separation by feature domain

• Sticker pack bundled with main app

  • Why: Demonstrates iOS 10 iMessage extension capabilities within the same project
  • Consequence: Binary size and complexity increase; sticker pack is tightly coupled to main app build

• Does not provide production-grade implementations—samples are educational prototypes
• Does not include unit tests or integration tests
• Does not handle edge cases or error recovery beyond basic framework examples
• Not a framework or library; purely a reference code repository
• Does not support iOS versions prior to iOS 10

• Avg cyclomatic complexity: ~5 — Samples are educational and intentionally straightforward; each isolates a single iOS 10 API with minimal business logic; estimated ~50–200 lines per sample

• Monolithic project structure with no modular separation (Medium) — iOS-10-Sampler.xcodeproj (root): All samples coexist in a single Xcode project without clear separation by feature; makes it difficult to extract or reuse individual samples
• No explicit error handling or permission prompts documented (Medium) — README.md (missing implementation details): Samples likely request microphone, camera, and haptic access but do not document permission request flows or fallback UI states in the README
• Simulator incompatibility without clear annotation (Low) — README.md (build instructions): Note states 'NOT run on Simulator' but root cause (Metal) is not obvious to newcomers; could lead to debugging confusion

• AVCapturePhotoOutput (Live Photo sample) (I/O latency) — Capture and encoding of Live Photo format is I/O-bound and may block main thread if not dispatched asynchronously
• SFSpeechRecognizer (Speech Recognition sample) (Computation / Network latency) — On-device speech recognition can be CPU-intensive; network-based fallback may introduce latency and require connectivity
• Metal rendering (if graphics-heavy samples present) (GPU contention) — GPU synchronization and pipeline stalls if sample does not properly manage Metal command encoding and resource lifecycle

Critical: Device-only, no Simulator. Code explicitly requires Metal, which is unavailable on Simulator—you must test on a physical iOS 10+ device. Xcode 8 required: modern Xcode versions may have compatibility issues with Swift 2.2 syntax; use Xcode 8 for best results. No Pod dependencies: there is no Podfile or CocoaPods setup; all code uses only Apple frameworks, so no dependency version lock files to manage. AVCapturePhotoOutput license: Live Photo capture uses private camera APIs that may be restricted in App Store review; check Apple's app review guidelines before shipping. No unit tests: repo contains zero test files; all validation is manual via the running app.

• Metal Performance Shaders (MPS) — iOS-10-Sampler uses MPS for real-time CNN-based digit and image recognition; understanding MPS is essential to grasp how the neural network demos achieve GPU acceleration without writing raw Metal kernels
• AVCapturePhotoOutput — The Live Photo Capturing example relies on AVCapturePhotoOutput (new in iOS 10) to capture both the image and motion metadata; learning this is key to implementing modern camera apps
• Speech Framework — The Speech Recognition demo is the primary iOS 10 introduction to on-device speech-to-text via SFSpeechRecognizer; critical for understanding iOS speech processing capabilities
• UIViewPropertyAnimator — Two demos (Position and Blur animators) showcase interactive, interruptible animations via fractionComplete; foundational for modern iOS animation beyond Core Animation
• UserNotifications Framework — The notification example uses the new UserNotifications API (replacing legacy UILocalNotification) with attachment support; essential for understanding iOS 10+ local and remote notifications
• NSPersistentContainer — The Core Data Stack example demonstrates NSPersistentContainer, which simplified Core Data boilerplate setup in iOS 10; important for understanding modern Core Data initialization patterns
• 3D Touch & UIPreviewInteraction — The Peek & Pop example uses UIPreviewInteraction for Peek/Pop gestures on supported devices; understanding this is necessary for apps targeting iPhone 6s+ with pressure-sensitive interactions

• shu223/iOS-11-Sampler — Direct successor collecting iOS 11 API samples (ARKit, Core ML, drag-and-drop) using the same educational structure
• raywenderlich/swift-algorithm-club — Complementary algorithmically-focused Swift examples; relevant for understanding the CNN algorithms used in Metal samples
• apple/swift-playground-samples — Official Apple repository of Swift Playgrounds and code samples; overlaps on modern iOS API demonstrations
• pointfreeco/swift-composable-architecture — Modern state management for Swift apps; useful for refactoring the MVC structure in this sampler into a scalable TCA pattern
• mattt/Alamofire — If any sample needs HTTP networking (e.g., for image recognition server calls), this is the standard Swift HTTP client library

To work on one of these in Claude Code or Cursor, paste: Implement the "<title>" PR idea from CLAUDE.md, working through the checklist as the task list.

Add comprehensive API coverage documentation for iOS 10 features

The README.md is truncated and doesn't list all the iOS 10 APIs covered by the sampler. Based on the file structure, there are features like Speech Recognition, Looper, Live Photo, Haptics, Core Data, Image Recognition, Notifications, and Stickers, but the README only partially documents these. A complete feature matrix would help new contributors understand what's implemented and what might be missing.

• [ ] Create a complete feature list in README.md documenting all iOS 10 APIs covered (Speech Recognition, AVPlayerLooper, Live Photos, Haptic Feedback, Core Data, Vision Framework, UserNotifications, Sticker Pack, etc.)
• [ ] For each feature, add a brief description of the implementation location and which ViewController/file contains the sample code
• [ ] Add a 'Getting Started' section with instructions on which features to explore first based on complexity level

Add unit tests for sample implementations

This is a sample/educational repository with no visible test files. While the focus is on API demonstrations, adding basic unit tests for core logic (e.g., speech recognition setup, AVPlayerLooper configuration, haptic feedback triggers) would serve as both validation and documentation of proper API usage patterns for contributors.

• [ ] Create Tests/ directory structure mirroring the main source structure
• [ ] Add unit tests for SpeechRecognition initialization and language selection logic
• [ ] Add tests for AVPlayerLooper setup and playback state management
• [ ] Add tests for haptic feedback engine initialization across different feedback types

Create a GitHub Actions workflow to validate Xcode project builds

The README states the project requires Xcode 8 and cannot run on Simulator due to Metal usage, but there's no CI validation. A GitHub Actions workflow using xcodebuild would catch build regressions early and help contributors verify their changes compile correctly on the specified iOS 10 SDK.

• [ ] Create .github/workflows/xcode-build.yml that runs xcodebuild on macOS-latest
• [ ] Configure the workflow to build for physical device destination (iOS 10 or later SDK)
• [ ] Add a build status badge to README.md referencing the workflow
• [ ] Document in CONTRIBUTING.md (if it exists, or create it) that PRs must pass this check

• Add unit tests for Core Data example: The SamplerStickerPack and TabBar customization demos have no test coverage; add XCTestCase files to test NSPersistentContainer setup and UITabBar badge customization to improve maintainability.
• Document Metal Performance Shaders CNN setup: The digit detection and image recognition examples use Metal Performance Shaders but lack inline code comments explaining the convolution pipeline; add detailed comments to DigitDetectionViewController and ImageRecognitionViewController on how MPS graphs are constructed.
• Create migration guide to iOS 11+: Write a new MIGRATION_GUIDE.md documenting which iOS 10 APIs were superseded (e.g., Speech Framework optional parameters, UserNotifications API expansion in iOS 12) and how to adapt these samples for modern iOS, helping learners transition from this historical reference.

This is an iOS sample/demo project with minimal security concerns. The codebase consists primarily of UI examples and asset files for iOS 10 API demonstrations. No dependencies, hardcoded secrets, injection vulnerabilities, or infrastructure misconfigurations were identified. The project is a compiled Xcode application targeting iOS devices, not a web application or service. Minor recommendations exist around general Swift/iOS best practices and keeping development tools updated.

LLM-derived; treat as a starting point, not a security audit.

• Open issues — current backlog
• Recent PRs — what's actively shipping
• Source on GitHub

Generated by RepoPilot. Verdict based on maintenance signals — see the live page for receipts. Re-run on a new commit to refresh.