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/IFTTT/RazzleDazzle 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 3y ago

• 9 active contributors
• Distributed ownership (top contributor 45% of recent commits)
• MIT licensed
• ⚠ Stale — last commit 3y ago
• ⚠ 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 IFTTT/RazzleDazzle repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/IFTTT/RazzleDazzle.

What it runs against: a local clone of IFTTT/RazzleDazzle — 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 IFTTT/RazzleDazzle | Confirms the artifact applies here, not a fork | | 2 | License is still MIT | Catches relicense before you depend on it | | 3 | Default branch main exists | Catches branch renames | | 4 | 5 critical file paths still exist | Catches refactors that moved load-bearing code | | 5 | Last commit ≤ 971 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of IFTTT/RazzleDazzle. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/IFTTT/RazzleDazzle.git
#   cd RazzleDazzle
#
# 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 IFTTT/RazzleDazzle and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "IFTTT/RazzleDazzle(\\.git)?\\b" \\
  && ok "origin remote is IFTTT/RazzleDazzle" \\
  || miss "origin remote is not IFTTT/RazzleDazzle (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 main >/dev/null 2>&1 \\
  && ok "default branch main exists" \\
  || miss "default branch main no longer exists"

# 4. Critical files exist
test -f "Source/Animator.swift" \\
  && ok "Source/Animator.swift" \\
  || miss "missing critical file: Source/Animator.swift"
test -f "Source/Animation.swift" \\
  && ok "Source/Animation.swift" \\
  || miss "missing critical file: Source/Animation.swift"
test -f "Source/AnimatedPagingScrollViewController.swift" \\
  && ok "Source/AnimatedPagingScrollViewController.swift" \\
  || miss "missing critical file: Source/AnimatedPagingScrollViewController.swift"
test -f "Source/Filmstrip.swift" \\
  && ok "Source/Filmstrip.swift" \\
  || miss "missing critical file: Source/Filmstrip.swift"
test -f "Source/Interpolatable.swift" \\
  && ok "Source/Interpolatable.swift" \\
  || miss "missing critical file: Source/Interpolatable.swift"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 971 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~941d)"
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/IFTTT/RazzleDazzle"
  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).

RazzleDazzle is a Swift keyframe animation framework that syncs animations to UIScrollView scroll position, enabling scrolling app intro animations tied to page offsets. It grew from IFTTT's Objective-C JazzHands library and provides both animation sequencing (opacity, scale, translation at specific scroll ranges) and AutoLayout-friendly paging scroll view scaffolding via AnimatedPagingScrollViewController. Single-package structure: core animation logic is likely in the root Swift files (not listed in top 60), example app lives in Example/Example/RazzleDazzleDemo with storyboards and asset catalog, and build configuration via Cartfile (Carthage). Main entry points are probably AnimatedPagingScrollViewController and keyframe animator classes referenced in README.

iOS app developers (primarily Swift) building interactive scrolling intros or onboarding flows who want keyframe animations bound to scroll position without managing CADisplayLink or scroll delegate math manually. Also used by IFTTT internally in their IF and DO apps.

Moderately mature and stable. Written in Swift with 93.5KB of code, available via Carthage and CocoaPods, and actively used in production (IF/DO apps). However, the repo shows typical signs of a mature-but-stable library: no recent commit activity visible in file list, no CI/testing infrastructure apparent (.gitignore and .swift-version present but no .travis.yml or test target listed), and single-maintainer risk under IFTTT org.

Low to medium risk. No external dependencies evident (Cartfile.private suggests dev-only use of Carthage), but the lack of visible test files and CI configuration is concerning for regression safety. Swift version pinning (.swift-version exists) mitigates some obsolescence risk, but lack of recent activity means iOS 15+ compatibility is not guaranteed without testing.

No active development visible from provided file list. The repo appears in maintenance mode—documentation is complete (banner, demo gif, README with install/usage examples), example app is fully featured (multiple image assets, storyboards for intro screens), but no recent changes, PRs, or milestones are evident.

Clone and open the example project:

git clone https://github.com/IFTTT/RazzleDazzle.git
cd RazzleDazzle/Example/Example
open RazzleDazzleDemo.xcodeproj

Then build and run in Xcode (iOS 8.0+ target). Carthage users: add github "IFTTT/RazzleDazzle" to Cartfile and run carthage update.

Daily commands: Open Example/Example/RazzleDazzleDemo.xcodeproj in Xcode and press Cmd+R to build and run on simulator/device. The demo app scrolls through animated intro pages (visible assets: Razzle.png, Dazzle.png, BigCloud.png, Plane.png, MusicNotes.png, etc.). No command-line build visible; Xcode project is the primary entry.

• Source/Animator.swift — Core animation engine that drives all keyframe-based animations; every animator and animation depends on this central orchestrator.
• Source/Animation.swift — Base animation protocol defining the interface for all animation types; understand this to extend the framework with new animation kinds.
• Source/AnimatedPagingScrollViewController.swift — Primary entry point for scroll-driven animations; the main way developers integrate RazzleDazzle into their apps.
• Source/Filmstrip.swift — Manages timing and progress tracking across keyframes; critical for understanding how animations synchronize with scroll position.
• Source/Interpolatable.swift — Protocol enabling smooth value interpolation between keyframes; essential for understanding how animations compute intermediate states.
• Source/EasingFunction.swift — Implements cubic Bézier easing curves for natural motion; understand this to customize animation timing.
• Source/Animatable.swift — Protocol that marks objects as animation targets; defines the minimal contract for objects that can be animated.

Add a new Animation Type

1. Create new Swift file in Source/ named after your animation (e.g., SourceNewPropertyAnimation.swift) (Source/[NewPropertyAnimation].swift)
2. Create a class that inherits from Animation and conforms to Interpolatable for your property type (Source/[NewPropertyAnimation].swift)
3. Implement the progress(frame:) method to compute interpolated values from keyframes (Source/[NewPropertyAnimation].swift)
4. Apply the animated value to your target object in the apply() method (Source/[NewPropertyAnimation].swift)
5. Add unit tests to Example/RazzleDazzleTests/RAZ[NewProperty]AnimationSpec.swift (Example/RazzleDazzleTests/RAZ[NewProperty]AnimationSpec.swift)

Integrate RazzleDazzle into a View Controller

1. Subclass AnimatedPagingScrollViewController instead of UIViewController (Source/AnimatedPagingScrollViewController.swift)
2. In setupAnimations() (called by viewDidLoad), create animations and add them to self.animator (Source/AnimatedPagingScrollViewController.swift)
3. Create animation instances (e.g., TranslationAnimation, AlphaAnimation) with target views and keyframes (Source/TranslationAnimation.swift)
4. Add keyframes using addKeyframe(at:value:) with page progress (0.0–1.0 range) (Source/Animation.swift)
5. Animator automatically drives animations as user scrolls; no additional code needed (Source/Animator.swift)

Customize Animation Timing with Easing

1. When creating an Animation, pass an EasingFunction to control timing curve (Source/EasingFunction.swift)
2. Choose from preset easing curves (linear, easeIn, easeOut, easeInOut) or create custom cubic Bézier (Source/EasingFunction.swift)
3. Custom easing: create CubicBezier instance with control points and wrap in EasingFunction (Source/CubicBezier.swift)
4. Animation applies easing to progress value before interpolating keyframe values (Source/Filmstrip.swift)

Animate AutoLayout Constraints

1. Instead of TranslationAnimation, use ConstraintConstantAnimation for layout-driven motion (Source/ConstraintConstantAnimation.swift)
2. Pass the NSLayoutConstraint and target constant values at each keyframe (Source/ConstraintConstantAnimation.swift)
3. For multiplier changes, use ConstraintMultiplierAnimation similarly (Source/ConstraintMultiplierAnimation.swift)
4. Animator applies constraint changes during scroll, triggering layout updates automatically (Source/Animator.swift)

• Swift — Modern, safe iOS language; type-safe animations reduce runtime errors in visual timing code
• UIScrollView-driven updates — Decouples animations from time; scroll position becomes source of truth for keyframe progress
• Cubic Bézier easing — Standard approach for natural motion; matches iOS system animation curves
• Keyframe interpolation — Lightweight and deterministic; computes on-demand for each frame without storing intermediate states
• AutoLayout support (ConstraintConstantAnimation) — Allows scroll-driven animation of constraint-based layouts without manual frame manipulation

• Scroll-driven (not time-driven) animations

  • Why: Scrolling intros naturally tie to scroll velocity and user gesture
  • Consequence: Cannot reuse animations outside scrolling context; requires AnimatedPagingScrollViewController subclass for typical use case

• Keyframes stored as progress (0

  • Why: undefined
  • Consequence: undefined

1. Swift version mismatch: .swift-version file pins a specific compiler; ensure local Xcode matches or module will fail to build. 2. Carthage-only example: Example/Cartfile.resolved suggests dependencies managed by Carthage; carthage update must be run before opening the example project, or it will have missing frameworks. 3. No explicit AutoLayout constraint setup: The keep(view:onPage:) function handles paging layout, but manual constraints on animated views must not conflict with the framework's internal pinning or animations will be overridden. 4. Scroll binding is position-only: Animations are keyed to contentOffset.x ranges, not to velocity or acceleration; rapid scrolling may skip frames if animation blocks are too expensive. 5. No visible test suite: Framework lacks unit tests; compatibility with iOS 12+ and iPhone X safe areas is untested.

• Keyframe Animation Binding to Scroll Position — Core to RazzleDazzle—animations are not time-based but position-based, keyed to UIScrollView contentOffset; essential to understand how scroll delegates map view property changes to discrete ranges
• AutoLayout Paging ScrollView Patterns — RazzleDazzle's keep(view:onPage:) avoids common AutoLayout pitfalls (content size ambiguity, rotation handling); learning this pattern prevents constraint conflicts in responsive paging layouts
• CADisplayLink and Frame Synchronization — Implied by scroll-driven animations; understanding how CADisplayLink syncs with screen refresh (60 vs 120 Hz) explains why RazzleDazzle ties to scroll events rather than timers
• View Property Animation Interpolation (Opacity, Scale, Translation) — RazzleDazzle animates discrete properties (alpha, transform) across scroll ranges; knowing linear vs easing interpolation and how Core Animation layers compose transforms is needed to extend it
• Scroll View Delegate Optimization for 60 FPS — Scroll animations must update views in delegate callbacks without blocking the main thread; understanding view.layer.cornerRadius vs CAShapeLayer and reducing opacity changes vs transform saves frames

• IFTTT/JazzHands — Predecessor Objective-C keyframe animation library that RazzleDazzle is built on; same scroll-binding animation concept, useful for Objective-C projects or learning the original design
• pinterest/PINRemoteImage — Companion lazy-loading image library often used with scrolling intros to avoid frame drops from image decoding during scroll animations
• facebook/pop — Alternative physics-based animation framework (uses CADisplayLink) that can be combined with RazzleDazzle for spring/decay animations alongside scroll binding
• airbnb/lottie-ios — Modern alternative for app intro animations using JSON Lottie files; better for complex motion design but less suited to scroll-position binding than RazzleDazzle
• realm/realm-swift — Not animation-related but commonly integrated into scrolling onboarding flows (e.g., to persist intro state or user progress)

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 unit tests for Example/Example/RazzleDazzleDemoTests

The test file Example/Example/RazzleDazzleDemoTests/RazzleDazzleDemoTests.swift exists but is likely minimal. RazzleDazzle's core animation framework needs test coverage for keyframe interpolation, timing calculations, and AutoLayout constraint animations. This is critical for a mature animation library to prevent regressions.

• [ ] Expand Example/Example/RazzleDazzleDemoTests/RazzleDazzleDemoTests.swift with tests for keyframe timing and interpolation
• [ ] Add tests for animation state management and scroll synchronization
• [ ] Add tests for AutoLayout constraint animation edge cases
• [ ] Verify test coverage reaches >70% for core animation classes

Add GitHub Actions CI workflow for Swift compilation and testing

The repo has Carthage (Example/Cartfile) and CocoaPods support but no automated CI. A GitHub Actions workflow would ensure PR quality, validate Swift version compatibility (.swift-version exists), and run tests on every commit. This is essential for an open-source framework.

• [ ] Create .github/workflows/ci.yml with Xcode build and test steps
• [ ] Configure the workflow to test against the Swift version in .swift-version
• [ ] Add test execution for Example/Example/RazzleDazzleDemoTests
• [ ] Set up artifact uploads for build logs and test results

Add API documentation comments and generate DocC documentation

The README is incomplete (cuts off mid-sentence: 'RazzleDazzle is t') and core framework classes likely lack proper Swift documentation comments. Adding DocC-compatible comments to the main animation classes and generating hosted documentation would significantly improve developer onboarding and discoverability.

• [ ] Add comprehensive documentation comments to main animation framework classes (look in RazzleDazzle source directory)
• [ ] Add parameter and return value documentation following DocC format
• [ ] Create .github/workflows/documentation.yml to generate and publish DocC archives
• [ ] Complete the truncated README.md section explaining what RazzleDazzle is for with specific examples

• Add unit tests for core animator classes (AnimatedPagingScrollViewController, keyframe binding). Create Tests/RazzleDazzleTests.swift to cover scroll position mapping, view attachment/detachment, and keep(view:onPage:) paging logic with XCTestCase.
• Document the animator API with code examples in README. Add a 'Usage' section showing how to instantiate a scroll animator, define keyframes for opacity/scale/translation, and bind it to a scroll view with concrete code snippets (currently README only shows installation).
• Add Swift Package Manager support. Create Package.swift in repo root to allow dependencies: [.package(url: "...")] in client Podfiles, since CocoaPods and Carthage are less popular post-Swift 5.5.

The RazzleDazzle iOS animation framework demonstrates a reasonably secure codebase structure. As a Swift-based UI animation library with no apparent data handling or network components, the attack surface is limited. Primary concerns are dependency management through CocoaPods and Carthage, which requires ongoing vigilance for upstream vulnerabilities. No hardcoded secrets, injection vulnerabilities, or infrastructure misconfigurations were identified in the provided file structure. The project follows iOS best practices with standard Xcode project organization. Regular dependency audits and Swift version management are recommended maintenance practices.

• Low · Missing .swift-version File Content Verification — .swift-version. The .swift-version file is present but its content is not provided for review. This file typically specifies the Swift compiler version and should be verified to ensure it's not pinned to an outdated or vulnerable version. Fix: Ensure the Swift version specified is current and patched. Regularly update to the latest stable Swift version.
• Low · Cartfile Dependencies Not Analyzed — Example/Cartfile, Example/Cartfile.private, Example/Cartfile.resolved. The project uses Carthage for dependency management (Cartfile, Cartfile.private, Cartfile.resolved present). The actual dependency versions and their security status cannot be verified from the provided information. Fix: Regularly audit dependencies using tools like Carthage's vulnerability scanning. Pin versions to known secure releases and monitor for security advisories on dependent libraries.
• Low · CocoaPods Dependency Management — RazzleDazzle.podspec. The project uses CocoaPods (RazzleDazzle.podspec present). The podspec file content was not provided for analysis of dependency specifications. Fix: Review the podspec to ensure all dependencies specify minimum secure versions. Use pod update with caution and validate dependencies before integrating updates.
• Low · Test Data in Example Project — Example/Example/RazzleDazzleDemo/Base.lproj/*.storyboard. The Example project contains storyboards and test assets that may contain hardcoded values or debugging information that could be accidentally exposed. Fix: Review storyboard files to ensure no sensitive data, test credentials, or debugging information is embedded. Keep test data minimal and secure.

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.