WAIT — Single-maintainer risk — review before adopting

• Last commit 4d ago
• 6 active contributors
• MIT licensed
• CI configured
• ⚠ Single-maintainer risk — top contributor 95% of recent commits
• ⚠ No test directory detected

_{Computed from maintenance signals — commit recency, contributor breadth, bus factor, license, CI, tests}

CYLTabBarController is an iOS UI library that adds Lottie animation support to UITabBar items and enables a custom center '+' button with a larger UITabBarItem. It provides out-of-the-box red badge indicators, dynamic badge refresh, and flat design tabbar components, tested on iOS 12+ through iOS 17 with Dark Mode support. Hybrid Objective-C and Swift library. Core UITabBar extension logic in CYLTabBarController/ directory (CAAnimation+CYLBadgeExtention, CYLPlusButton.m/.h, CYLTabBar+CYLTabBarControllerExtention). CYLFlatDesignTabBar/ subdirectory contains the flat design implementation (CYLBaseView, CYLFlatDesignTabBar). Base controller classes (CYLBaseViewController, CYLBaseNavigationController, CYLBaseTableViewController) provide foundation for integrating the custom tabbar.

iOS developers building apps with custom tabbar navigation who want animated tab transitions without writing extensive UITabBar customization code. Particularly useful for Chinese-market apps that use the center '+' button pattern for primary actions.

Actively maintained and production-ready. The project has a clear version history (CHANGELOG.md present), comprehensive CI setup (.travis.yml), and supports current iOS versions (iOS 12+, tested through iOS 17). Single active maintainer (ChenYilong) with regular updates, but lacks visible automated test suite in the file list.

Moderate risk: single-maintainer project with Objective-C/Swift mixed codebase (131KB Swift, 6KB Ruby). Dependency on Lottie animation framework introduces external complexity. No visible test directory structure suggests limited automated testing coverage. Check open issues and last commit timestamp before production adoption.

Project maintains active release tracking (CHANGELOG.md present, releases.atom feed). GitHub issue templates exist for bug reports and feature requests (/.github/ISSUE_TEMPLATE/). Build configuration via .travis.yml suggests CI/CD pipeline in place. Specific recent activity unclear from file metadata alone, but repository structure shows ongoing maintenance.

Clone via: git clone https://github.com/ChenYilong/CYLTabBarController.git. Open CYLTabBarController.xcworkspace (not .xcodeproj) in Xcode. Install dependencies via CocoaPods: pod install (see CYLTabBarController.podspec). Build and run the example project to see animated tabbar in action.

Daily commands: Open CYLTabBarController.xcworkspace in Xcode, select example scheme, press Cmd+R. Or via CLI: xcodebuild -workspace CYLTabBarController.xcworkspace -scheme CYLTabBarController build. Inspect example app under CYLTabBarController/Example (if present in directory structure not fully detailed in file list).

• CYLTabBarController/CYLTabBarController.h — Main public header defining the CYLTabBarController interface and core API—entry point for all consumers
• CYLTabBarController/CYLTabBarController.m — Core implementation managing tab bar lifecycle, item configuration, and animation orchestration
• CYLTabBarController/CYLTabBar.m — Custom UITabBar subclass implementing layout, badge rendering, and Lottie animation injection
• CYLTabBarController/CYLPlusButton.h — Central button handler for the oversized middle '+' tab item that triggers the primary action
• CYLTabBarController/CYLTabBar+CYLTabBarControllerExtention.m — Extension layer binding tab bar items to badge/animation logic and handling Lottie Drawable integration
• CYLTabBarController/LottieSwift/CompatibleLottie.swift — Swift-Objective-C bridge enabling Lottie animation framework integration across mixed-language codebase
• CYLTabBarController.podspec — CocoaPods manifest declaring dependencies, version, and platform requirements—controls distribution

Add a Lottie Animation to a Tab Item

1. Prepare a Lottie JSON animation file and add to Xcode project assets (CYLTabBarController/LottieSwift/CompatibleLottie.swift)
2. In your CYLTabBarController subclass, set the animation via the public API (CYLTabBarController/CYLTabBarController.h)
3. The CYLTabBar extension automatically wraps the Lottie view and manages playback on item selection (CYLTabBarController/CYLTabBar+CYLTabBarControllerExtention.m)
4. Customize animation trigger behavior by subclassing CYLTabBar and overriding item selection delegate methods (CYLTabBarController/CYLTabBar.m)

Add a Red Badge Indicator to a Tab Item

1. Call the badge configuration method on your tab bar item (uses UITabBarItem+CYLBadgeExtention) (CYLTabBarController/UITabBarItem+CYLBadgeExtention.h)
2. Set badge value and customize appearance (color, size, offset) in CYLTabBar rendering layer (CYLTabBarController/CYLTabBar.m)
3. Badge animations (pulse, bounce) are defined in CAAnimation category (CYLTabBarController/CAAnimation+CYLBadgeExtention.m)
4. Update badge at runtime by modifying the tab item and triggering CYLTabBar refresh (CYLTabBarController/UIView+CYLBadgeExtention.m)

Create a Custom Center '+' Button Tab Item

1. Configure the middle tab item as a plus button by setting a flag in CYLTabBarController initialization (CYLTabBarController/CYLTabBarController.m)
2. The CYLPlusButton class handles rendering and touch handling for the oversized center button (CYLTabBarController/CYLPlusButton.m)
3. Customize button appearance (size, color, image) via UITabBarItem+CYLTabBarControllerExtention (CYLTabBarController/UITabBarItem+CYLTabBarControllerExtention.m)
4. Set a target action or custom handler that triggers when the plus button is tapped (CYLTabBarController/CYLTabBar.m)

Switch to Flat Glass Design Tab Bar

1. Instead of default CYLTabBar, instantiate CYLFlatDesignTabBar in your controller initialization (CYLTabBarController/CYLTabBarController.m)
2. Configure flat design parameters (blur effect, glass color, corner radius) in the tabBar property (CYLTabBarController/CYLFlatDesignTabBar/CYLFlatDesignTabBar-ObjectiveC/CYLFlatDesignTabBar.m)
3. Badge and animation behavior remains the same—CYLFlatDesignTabBar inherits from CYLBaseView (CYLTabBarController/CYLFlatDesignTabBar/CYLFlatDesignTabBar-ObjectiveC/CYLBaseView.m)

• Objective-C + Swift Bridge — Lottie is Swift/Kotlin native; CompatibleLottie.swift bridges into legacy Objective-C codebase for animation support
• Category Extensions (UIKit) — Modular addition of badge, animation, and tab bar behavior without subclassing UITabBarItem/UIBarButtonItem
• Core Animation (CABasicAnimation) — Lightweight, GPU-accelerated badge animations (pulse, scale, bounce) without external dependencies
• Custom UITabBar Subclass — Required to override layoutSubviews for custom item positioning, oversized center button, and Lottie injection

• Many fine-grained category extensions vs. fewer monolithic classes
  • Why:
  • Consequence: undefined

Objective-C/Swift interop requires careful bridging header setup if adding Swift code. Lottie animation files (.json) must be included in app bundle and referenced correctly. Badge animations use CABasicAnimation with timing—test on actual devices as simulator performance differs. Center '+' button positioning may conflict with Safe Area on notched/Dynamic Island devices if not carefully handled. CocoaPods integration required; direct binary frameworks may have conflicts.

• UITabBar Category Extensions — CYLTabBarController heavily uses Objective-C categories (CYLTabBar+CYLTabBarControllerExtention) to extend UITabBar without subclassing; understanding this pattern is essential to modifying animation behavior
• Core Animation (CABasicAnimation, CAKeyframeAnimation) — Badge animations and tab item transitions use CABasicAnimation; this library demonstrates timing functions, group animations, and animation delegation patterns critical to smooth UI
• Lottie Animation Format (.json) — Core feature depends on Lottie JSON animation files exported from After Effects; understanding the JSON structure and render pipeline is necessary to create custom animations for tabbar items
• Protocol-Based Badge Protocol (CYLBadgeProtocol) — Uses Swift/Objective-C protocol pattern to enable extensible badge customization without modifying core library; demonstrates dependency inversion principle
• Safe Area Layout (notch/Dynamic Island handling) — Center '+' button and tabbar positioning must account for Safe Area on modern iPhone layouts; critical for correct appearance across device types (iPhone 14 Pro, iPad Pro notches)
• Dark Mode Trait Collections — Badge colors and animation appearance must adapt to dark/light mode; library mentions iOS 13+ Dark Mode support requiring traitCollectionDidChange() handling
• UITabBarController Delegation & Customization — Extending UITabBarController behavior for center button actions and selected tab animations requires understanding delegate patterns and UITabBarControllerDelegate protocol

• Ramotion/animated-tab-bar — Direct competitor providing animated UITabBar items without center '+' button; useful for comparison of animation approaches
• lottie-ios/lottie-ios — Upstream dependency providing Lottie animation engine that CYLTabBarController wraps for tabbar items
• airbnb/lottie-ios — Official Lottie iOS implementation; referenced in CYLTabBarController for all animation rendering
• ChenYilong/iOSBlog — Author's personal blog/issue tracker referenced in README for community discussion, QQ/Telegram group coordination, and technical blog posts about this library
• instagram/IGListKit — UICollectionView foundation that pairs well with custom tabbar navigation for complex feed-based layouts common in Chinese social apps

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 unit tests for CYLTabBar animation and badge rendering

The repo has extensive badge and animation logic (CAAnimation+CYLBadgeExtention, UITabBarItem+CYLBadgeExtention) but no visible test files in the structure. This is critical for a UI library where animation timing and badge positioning directly affect user experience. Tests would catch regressions when updating Lottie compatibility or iOS versions.

• [ ] Create CYLTabBarControllerTests/ directory with XCTest suite
• [ ] Add tests for CAAnimation+CYLBadgeExtention.m badge animations (show/hide/position)
• [ ] Add tests for UITabBarItem+CYLBadgeExtention.m badge rendering across different content sizes
• [ ] Add tests for CYLTabBar.m center button positioning and Lottie animation initialization
• [ ] Add snapshot tests for CYLFlatDesignTabBar rendering on light/dark modes and different device sizes

Add GitHub Actions CI workflow to test iOS 12+ and latest iOS compatibility

The .travis.yml suggests old CI setup, and README claims iOS 12.0+ and iOS26 testing but no active CI workflow is visible. Given the repo supports Lottie animations and Dark Mode, automated testing across multiple iOS versions is essential to catch compatibility issues early, especially before CocoaPods releases.

• [ ] Create .github/workflows/ios-build-test.yml with xcodebuild for iOS 12, 15, 16, 17 simulators
• [ ] Add build step for CYLTabBarController.xcworkspace with SPM/CocoaPods dependency resolution
• [ ] Add test step running CYLTabBarControllerTests suite if created
• [ ] Add Dark Mode and Light Mode rendering validation using snapshot testing
• [ ] Update or remove .travis.yml after migration to GitHub Actions

Extract and document the Lottie animation integration pattern in CompatibleLottie.swift

CYLTabBarController/LottieSwift/CompatibleLottie.swift exists but has no corresponding documentation or usage examples. The README mentions 'Lottie animation TabBar with one line of code' but integration steps are unclear. This integration layer is a key differentiator of the library and deserves clear documentation.

• [ ] Review CompatibleLottie.swift and document the Lottie version compatibility strategy it implements
• [ ] Add code examples to README showing: 1) basic Lottie animation setup, 2) custom animation files, 3) version compatibility handling
• [ ] Create LOTTIE_INTEGRATION.md documenting supported Lottie versions and migration notes
• [ ] Add inline code comments in CompatibleLottie.swift explaining why version abstraction is needed
• [ ] Link to example Lottie animation JSON files in the demo project or docs/ directory

• Add unit tests for CYLBadgeProtocol.h badge display/hide lifecycle—currently no visible test directory suggests this gap exists. Start with test_badge_appears_on_controller.swift.
• Document the Lottie animation JSON file format requirements in README with a concrete example (e.g., animation file structure, frame count, naming conventions) since this is the main feature but lacks detailed guide.
• Add Dark Mode-specific badge color overrides in CAAnimation+CYLBadgeExtention.m—currently mentions Dark Mode support in README but implementation may not handle all edge cases for badge contrast in dark themes.

The CYLTabBarController codebase is primarily a UI library with moderate security posture. Main concerns include Objective-C runtime manipulation through categories, Swift-Objective-C interoperability memory safety, and lack of comprehensive input validation in badge extensions. The library lacks hardcoded secrets or injection vulnerabilities typical of data-handling code. No critical infrastructure or dependency issues identified. Recommended actions: audit category implementations for conflicts, review memory management at Swift-ObjC boundaries, add input validation to user-facing APIs, and extract hardcoded values to constants.

• Medium · Objective-C Runtime Manipulation via Extensions — CYLTabBarController/UITabBarItem+*.m, CYLTabBarController/UIView+*.m, CYLTabBarController/UIControl+*.m, and other extension files. The codebase extensively uses Objective-C categories (extensions) for UIKit components (UITabBarItem, UIView, UIControl, etc.). This pattern can lead to method swizzling vulnerabilities if not carefully implemented. Improper extension implementations could override critical security-related methods or introduce unexpected behavior. Fix: Audit all category implementations to ensure they don't override security-critical methods. Use proper namespacing for extension methods (prefix with 'cyl_' or similar). Implement defensive checks to prevent unintended method conflicts with other libraries.
• Medium · Potential Memory Safety Issues in Swift/Objective-C Interop — CYLTabBarController/LottieSwift/CompatibleLottie.swift, Swift-Objective-C interface boundaries. The project mixes Objective-C and Swift code (CompatibleLottie.swift), which can introduce memory management issues at the bridge boundary. Swift's memory safety guarantees don't extend automatically to Objective-C interoperability, and improper bridging could lead to use-after-free or buffer overflow scenarios. Fix: Review all Swift-Objective-C bridging code. Ensure proper memory management with autoreleasepool blocks where needed. Use Swift's strong type system to validate Objective-C object lifecycles. Consider adding unit tests for memory management in interop code.
• Low · Missing Input Validation in Badge Extensions — CYLTabBarController/CAAnimation+CYLBadgeExtention.*, CYLTabBarController/UITabBarItem+CYLBadgeExtention.m, CYLTabBarController/UIView+CYLBadgeExtention.m. Badge-related extensions (CAAnimation+CYLBadgeExtention., UITabBarItem+CYLBadgeExtention.) may accept user input for badge values without proper validation. This could lead to unexpected behavior if malformed data is provided. Fix: Add input validation for badge content, particularly for numeric badge values. Implement bounds checking and sanitization for string inputs to prevent crashes or unexpected UI behavior.
• Low · Hardcoded Configuration Values — CYLTabBarController/*.m implementation files, particularly animation and styling code. The codebase may contain hardcoded animation parameters, colors, or layout constants in implementation files rather than configuration. This reduces flexibility and could expose design decisions in compiled code. Fix: Extract magic numbers and hardcoded values into CYLConstants.h or a configuration file. Use symbolic constants for all animation durations, colors, and layout measurements.
• Low · Potential XPC/IPC Exposure in Foundation Extensions — CYLTabBarController/NSObject+CYLTabBarControllerExtention.m. NSObject+CYLTabBarControllerExtention extends the base NSObject class with custom methods. If these methods interact with system services without proper sandboxing checks, they could be exploited via XPC message passing. Fix: Ensure all NSObject extensions validate the caller context and implement proper access controls. Add checks to prevent unintended exposure via XPC or inter-process communication.

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

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

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/ChenYilong/CYLTabBarController 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.

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

What it runs against: a local clone of ChenYilong/CYLTabBarController — 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 ChenYilong/CYLTabBarController | 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 ≤ 34 days ago | Catches sudden abandonment since generation |

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

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "ChenYilong/CYLTabBarController(\\.git)?\\b" \\
  && ok "origin remote is ChenYilong/CYLTabBarController" \\
  || miss "origin remote is not ChenYilong/CYLTabBarController (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 "CYLTabBarController/CYLTabBarController.h" \\
  && ok "CYLTabBarController/CYLTabBarController.h" \\
  || miss "missing critical file: CYLTabBarController/CYLTabBarController.h"
test -f "CYLTabBarController/CYLTabBarController.m" \\
  && ok "CYLTabBarController/CYLTabBarController.m" \\
  || miss "missing critical file: CYLTabBarController/CYLTabBarController.m"
test -f "CYLTabBarController/CYLTabBar.m" \\
  && ok "CYLTabBarController/CYLTabBar.m" \\
  || miss "missing critical file: CYLTabBarController/CYLTabBar.m"
test -f "CYLTabBarController/CYLPlusButton.h" \\
  && ok "CYLTabBarController/CYLPlusButton.h" \\
  || miss "missing critical file: CYLTabBarController/CYLPlusButton.h"
test -f "CYLTabBarController/CYLTabBar+CYLTabBarControllerExtention.m" \\
  && ok "CYLTabBarController/CYLTabBar+CYLTabBarControllerExtention.m" \\
  || miss "missing critical file: CYLTabBarController/CYLTabBar+CYLTabBarControllerExtention.m"

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

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