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/Ramotion/animated-tab-bar 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 4y ago

• 8 active contributors
• MIT licensed
• CI configured
• ⚠ Stale — last commit 4y ago
• ⚠ Concentrated ownership — top contributor handles 58% of recent commits
• ⚠ 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 Ramotion/animated-tab-bar repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/Ramotion/animated-tab-bar.

What it runs against: a local clone of Ramotion/animated-tab-bar — 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 Ramotion/animated-tab-bar | 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 ≤ 1595 days ago | Catches sudden abandonment since generation |

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

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "Ramotion/animated-tab-bar(\\.git)?\\b" \\
  && ok "origin remote is Ramotion/animated-tab-bar" \\
  || miss "origin remote is not Ramotion/animated-tab-bar (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 "RAMAnimatedTabBarController/RAMAnimatedTabBarController.swift" \\
  && ok "RAMAnimatedTabBarController/RAMAnimatedTabBarController.swift" \\
  || miss "missing critical file: RAMAnimatedTabBarController/RAMAnimatedTabBarController.swift"
test -f "RAMAnimatedTabBarController/RAMItemAnimationProtocol.swift" \\
  && ok "RAMAnimatedTabBarController/RAMItemAnimationProtocol.swift" \\
  || miss "missing critical file: RAMAnimatedTabBarController/RAMItemAnimationProtocol.swift"
test -f "RAMAnimatedTabBarController/RAMAnimatedTabBarItem.swift" \\
  && ok "RAMAnimatedTabBarController/RAMAnimatedTabBarItem.swift" \\
  || miss "missing critical file: RAMAnimatedTabBarController/RAMAnimatedTabBarItem.swift"
test -f "RAMAnimatedTabBarController/Animations/BounceAnimation/RAMBounceAnimation.swift" \\
  && ok "RAMAnimatedTabBarController/Animations/BounceAnimation/RAMBounceAnimation.swift" \\
  || miss "missing critical file: RAMAnimatedTabBarController/Animations/BounceAnimation/RAMBounceAnimation.swift"
test -f "RAMAnimatedTabBarController/RAMBadge/RAMBadge.swift" \\
  && ok "RAMAnimatedTabBarController/RAMBadge/RAMBadge.swift" \\
  || miss "missing critical file: RAMAnimatedTabBarController/RAMBadge/RAMBadge.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 1595 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~1565d)"
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/Ramotion/animated-tab-bar"
  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).

RAMAnimatedTabBarController is a Swift UIKit library that adds customizable animations to iOS tab bar items and their icons when tapped. It provides a drop-in replacement for UITabBarController with built-in animation presets (Bounce, Rotation, Fume, Frame) that automatically animate tab icons and transitions without requiring Core Animation code in your app. Simple modular structure: RAMAnimatedTabBarController/ contains the core controller class and four animation subdirectories (BounceAnimation/, RotationAnimation/, FumeAnimation/, FrameAnimation/), each exposing a single animation class implementing RAMItemAnimationProtocol. RAMAnimatedTabBarItem wraps UITabBarItem with animation state. RAMBadge/ handles badge rendering. RAMAnimatedTabBarDemo/ is a complete Xcode project demonstrating all features.

iOS app developers using Swift and UIKit who want polished, pre-built tab bar animations without writing custom CABasicAnimation or CAKeyframeAnimation code. Particularly useful for designers and developers at agencies building consumer-facing apps that need premium micro-interactions.

This is a mature, production-ready library that supports iOS 9.0+ and Swift 5.0, includes CI/CD via Travis, has CocoaPods/Carthage/SPM support, and contains unit tests (AnimatedTabBarTests.swift, RAMBadgeTests.swift). However, the repo shows signs of minimal recent maintenance—last activity is not explicitly stated in the data, and the codebase is primarily 2017-era Swift without modern SwiftUI support.

Low-to-medium risk: the library has no external pod dependencies (self-contained in RAMAnimatedTabBarController folder), but it is UIKit-only and will not work in SwiftUI-first apps. The single-organization ownership (Ramotion) and lack of visible recent commits suggest limited active development; any critical bugs may require forking. The Objective-C remnants (490 lines) indicate older code paths that may not be maintained.

No active development is evident from the provided file snapshot. The codebase appears static with stable APIs; the most recent visible structure is the Swift 5.0 configuration and test suite setup in AnimatedTabBarTests/.

Clone the repo: git clone https://github.com/Ramotion/animated-tab-bar.git. Install via CocoaPods with pod 'RAMAnimatedTabBarController' in your Podfile, or manually drag the RAMAnimatedTabBarController/ folder into your Xcode project. Open RAMAnimatedTabBarDemo/RAMAnimatedTabBarDemo.xcodeproj to see the demo app running on iOS 9.0+.

Daily commands: Open RAMAnimatedTabBarDemo/RAMAnimatedTabBarDemo.xcodeproj in Xcode, select the RAMAnimatedTabBarDemo scheme, and press Cmd+R to run on iOS 9.0+ simulator or device.

• RAMAnimatedTabBarController/RAMAnimatedTabBarController.swift — Core UITabBarController subclass that orchestrates all animated tab bar behavior and item lifecycle—required reading to understand the library's main entry point.
• RAMAnimatedTabBarController/RAMItemAnimationProtocol.swift — Protocol definition that all animation types must conform to; critical for understanding how to extend or create new tab bar animations.
• RAMAnimatedTabBarController/RAMAnimatedTabBarItem.swift — Wrapper around UITabBarItem that adds animation state and lifecycle; every tab bar item animation depends on this class.
• RAMAnimatedTabBarController/Animations/BounceAnimation/RAMBounceAnimation.swift — Reference implementation of RAMItemAnimationProtocol showing the pattern used by all other animation types in the library.
• RAMAnimatedTabBarController/RAMBadge/RAMBadge.swift — Badge view component for displaying notifications on tab items; common feature that integrates with the animated tab bar.
• RAMAnimatedTabBarDemo/RAMAnimatedTabBarDemo/AppDelegate.swift — Demo app entry point showing how to integrate and configure RAMAnimatedTabBarController in a real application.

• RAMAnimatedTabBarController (UITabBarController, UITabBar, Core Animation) — Main entry point; manages tab selection, delegates animation dispatch to items, handles view lifecycle and tab bar geometry.
  • Failure mode: If tab selection is slow or animations stutter, likely cause is blocking main thread or excessive CAAnimation creation.

Add a New Animation Type

1. Create a new Swift file in RAMAnimatedTabBarController/Animations/{YourAnimationName}/ directory (RAMAnimatedTabBarController/Animations/{YourAnimationName}/RAM{YourAnimationName}.swift)
2. Import UIKit and create a class conforming to RAMItemAnimationProtocol (RAMAnimatedTabBarController/RAMItemAnimationProtocol.swift)
3. Implement required methods: animate(tabBarItem:toIndex:) and selectionAnimation() returning CAAnimation (RAMAnimatedTabBarController/Animations/BounceAnimation/RAMBounceAnimation.swift)
4. Use CABasicAnimation or CAKeyframeAnimation to define the visual transformation of the tab item icon/label (RAMAnimatedTabBarController/Animations/RotationAnimation/RAMRotationAnimation.swift)
5. In the demo app, assign your animation to a tab item via RAMAnimatedTabBarItem's animation property (RAMAnimatedTabBarDemo/RAMAnimatedTabBarDemo/AppDelegate.swift)

Configure Animated Tab Bar in a View Controller

1. Make your main view controller inherit from RAMAnimatedTabBarController instead of UITabBarController (RAMAnimatedTabBarController/RAMAnimatedTabBarController.swift)
2. Create child view controllers for each tab and add them via viewControllers property (inherited from UITabBarController) (RAMAnimatedTabBarDemo/RAMAnimatedTabBarDemo/AppDelegate.swift)
3. For each tab bar item, cast to RAMAnimatedTabBarItem and set its animation property (RAMAnimatedTabBarController/RAMAnimatedTabBarItem.swift)
4. Optionally add badges by accessing RAMBadge on each item for notification indicators (RAMAnimatedTabBarController/RAMBadge/RAMBadge.swift)

Add a Badge to a Tab Item

1. Get reference to the tab bar item (as RAMAnimatedTabBarItem) from the controller's tabBar (RAMAnimatedTabBarController/RAMAnimatedTabBarItem.swift)
2. Create or access the item's badge property and configure text, color, and position (RAMAnimatedTabBarController/RAMBadge/RAMBadge.swift)
3. The badge will be automatically added as a subview and animated along with tab selection (RAMAnimatedTabBarController/RAMAnimatedTabBarController.swift)

• Core Animation (CABasicAnimation, CAKeyframeAnimation) — Provides high-performance, GPU-accelerated animations for smooth 60fps icon and tab item transformations without blocking the main thread.
• UITabBarController subclass (RAMAnimatedTabBarController) — Integrates seamlessly with iOS standard tab bar lifecycle and respects UIKit's view controller containment; reduces boilerplate for developers.
• Swift protocols (RAMItemAnimationProtocol) — Enables loose coupling and extensibility; users can implement custom animations without modifying core library code.

• Animations run on every tab selection with no opt-out per item

  • Why: Ensures consistent, polished UX across all tabs in the library's design philosophy.
  • Consequence: Cannot disable animation for performance-sensitive scenarios without subclassing; all items must animate.

• Badge is a separate view layer overlaid on tab item

  • Why: Keeps badge logic independent and reusable; simplifies animation coordination.
  • Consequence: Badge layout and positioning must account for tab bar geometry; may require manual adjustments for custom tab bar sizes.

• Animation protocol uses synchronous CAAnimation creation

  • Why: Simplicity and immediate dispatch; reduces state management complexity.
  • Consequence: Complex animations (e.g., multi-stage fume particles) must be pre-computed; runtime animation generation is not supported.

• Support for customizable tab bar height or non-standard tab bar layouts (fixed to iOS UITabBar constraints).
• Real-time animation parameter adjustment during runtime (animations are static per item).
• Programmatic control of animation timing or easing beyond CAMediaTimingFunction presets.
• Integration with SwiftUI or modern concurrency APIs (UIKit-only library).
• Support for dynamic island or notch-aware tab bar positioning.

Storyboard/XIB dependency: animations must be connected via @IBOutlet in Interface Builder (no programmatic animation assignment shown in README), making headless/programmatic setup non-obvious. The RAMBadge API may conflict with native iOS badge notifications if both are used on the same tab item. No ARC or memory-leak guards visible—test with Instruments when subclassing. The library does not support landscape tab bar rotation edge cases if tabs are hidden during animation.

• CABasicAnimation and CAKeyframeAnimation — The entire animation system is built on Core Animation; understanding CABasicAnimation (linear property transitions) vs CAKeyframeAnimation (complex paths) is essential to extending or debugging animations.
• Protocol-Driven Design (RAMItemAnimationProtocol) — The library's extensibility hinges on this protocol; all animations conform to it, making the codebase pluggable and testable without inheritance hierarchies.
• IBDesignable and IBInspectable — The storyboard integration relies on these UIKit attributes to make RAMAnimatedTabBarItem editable in Interface Builder; critical for understanding the XIB/storyboard workflow.
• UITabBarController Delegate Pattern — RAMAnimatedTabBarController overrides UITabBarControllerDelegate methods to intercept tab selection and trigger animations; understanding the delegate chain is key to customization.
• Affine Transforms and CGAffineTransform — Several animations (e.g., rotation, scaling) use CGAffineTransform to manipulate tab icon geometry; essential knowledge for animation math.

• Ramotion/circle-menu — Similar Ramotion library providing circular menu animations—demonstrates the same protocol-driven animation pattern for reference.
• Ramotion/gliding-collection — Ramotion's collection view animation library using identical architecture; good for understanding the broader Ramotion animation ecosystem.
• airbnb/lottie-ios — Production-grade alternative that animates tab bars via JSON-based motion designs rather than hardcoded animation classes—more flexible but heavier weight.
• PangMo5/SwiftIconFont — Companion library for icon management in tab bars; often paired with animated-tab-bar for dynamic icon switching.

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 RAMAnimatedTabItem and animation protocols

The test suite is minimal (only AnimatedTabBarTests.swift and RAMBadgeTests.swift exist). Critical animation classes like RAMBounceAnimation, RAMRotationAnimation, RAMFumeAnimation, and RAMFrameItemAnimation lack unit tests. This is high-value because animation timing and visual accuracy are core to this library's functionality, and tests would catch regressions when animations are modified.

• [ ] Create RAMAnimatedTabBarDemo/AnimatedTabBarTests/RAMAnimationTests.swift to test RAMBounceAnimation.swift behavior (duration, scale values, completion callbacks)
• [ ] Create RAMAnimatedTabBarDemo/AnimatedTabBarTests/RAMRotationAnimationTests.swift to verify RAMRotationAnimation.swift produces correct rotation transforms
• [ ] Create RAMAnimatedTabBarDemo/AnimatedTabBarTests/RAMFrameAnimationTests.swift to validate RAMFrameItemAnimation.swift frame calculations
• [ ] Create RAMAnimatedTabBarDemo/AnimatedTabBarTests/RAMItemAnimationProtocolTests.swift to test RAMItemAnimationProtocol.swift conformance across all animation types
• [ ] Add tests for RAMAnimatedTabBarController.swift tab switching and badge interactions

Add GitHub Actions CI workflow for Swift testing and linting

The repo has .travis.yml for legacy CI but no modern GitHub Actions workflow. A GitHub Actions workflow would provide faster feedback for PRs, test against multiple iOS SDK versions, and run SwiftLint on RAMAnimatedTabBarController/ source files. This is critical for an open-source library to maintain code quality and catch issues early.

• [ ] Create .github/workflows/swift-tests.yml with steps to: build Package.swift, run AnimatedTabBarTests, and test against iOS 13+ SDK versions
• [ ] Add SwiftLint step in workflow to lint RAMAnimatedTabBarController/ directory (check RAMAnimatedTabBarController.swift and RAMAnimatedTabItem.swift for style consistency)
• [ ] Configure workflow to run on push to main/develop branches and all PRs
• [ ] Consider adding code coverage reporting step using codecov or similar

Document animation customization API and add code examples for each animation type

While RAMItemAnimationProtocol.swift defines the protocol, there is no dedicated documentation explaining how to create custom animations or how each built-in animation (Bounce, Rotation, Fume, Frame) differs in behavior. The README only shows a GIF. Developers need clear examples of RAMBounceAnimation, RAMRotationAnimation, RAMFumeAnimation, and RAMFrameItemAnimation usage.

• [ ] Create ANIMATIONS.md documenting RAMItemAnimationProtocol.swift structure and required methods
• [ ] Add example code blocks showing how to instantiate and configure each of: RAMBounceAnimation.swift, RAMRotationAnimation.swift, RAMFumeAnimation.swift, RAMFrameItemAnimation.swift
• [ ] Document RAMAnimatedTabBarController+BottomLine.swift customization options with code samples
• [ ] Add subsection in ANIMATIONS.md explaining how to create a custom animation by implementing RAMItemAnimationProtocol.swift
• [ ] Include parameter explanations (duration, delay, spring constants where applicable) for each animation class

• Add SwiftUI support: wrap RAMAnimatedTabBarController in UIViewControllerRepresentable to enable use in SwiftUI apps. Start in a new RAMAnimatedTabBarController/SwiftUI/ directory.
• Write integration tests for tab bar transitions: RAMAnimatedTabBarTests.swift has unit tests but no XCUITest cases. Add tests in AnimatedTabBarTests/ that simulate rapid taps and animation cancellation.
• Document animation protocol with example: RAMItemAnimationProtocol lacks inline code examples. Add a new markdown file Examples/CustomAnimation.md with a complete copy-paste example of creating a custom pulse animation.

The RAMAnimatedTabBarController library is a UI animation framework with minimal security attack surface. No critical vulnerabilities were identified based on available code structure. The codebase appears to be a pure UI library without network operations, data persistence, or authentication logic. Primary recommendations: (1) Ensure all dependencies in Package.swift and podspec are from official sources and regularly updated; (2) Remove user-specific IDE files from version control; (3) Maintain code review practices for any future authentication or data handling features. The library's focused scope on tab bar animations significantly reduces security risk compared to broader frameworks.

• Low · Missing Package.swift Dependencies Information — Package.swift. The Package.swift file content was not provided for analysis. This file should declare all Swift package dependencies with specific versions to ensure reproducible builds and prevent unexpected dependency updates that could introduce vulnerabilities. Fix: Provide and review Package.swift to ensure all dependencies are pinned to specific versions and from trusted sources. Use version constraints appropriately (e.g., .upToNextMajor() for stability).
• Low · Podspec File Not Reviewed — RAMAnimatedTabBarController.podspec. The RAMAnimatedTabBarController.podspec file was not analyzed. Podspec files define dependencies and their versions, which are critical for supply chain security. Fix: Review the podspec file to ensure all dependencies are from official sources, pinned to secure versions, and regularly updated for security patches.
• Low · User Data Directory in Version Control — RAMAnimatedTabBarDemo/RAMAnimatedTabBarDemo.xcodeproj/xcuserdata/. Xcode user data directories (.xcuserdata) are present in the repository, which may contain sensitive build settings, code snippets, or local configuration. Fix: Add .xcuserdata to .gitignore to prevent committing user-specific Xcode settings and configuration files.

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.