# VCTransitionsLibrary: iOS 7 custom transitions with reusable animation and interaction controllers > VCTransitionsLibrary offers a set of Objective-C animation and interaction controllers for iOS 7 custom view controller transitions, covering flip, fold, cube, portal, and more. It is a straightforward drop-in library, but its age and licensing require careful consideration before adoption. **ColinEberhardt/VCTransitionsLibrary** — GitHub describes it as A collection of iOS7 animation controllers and interaction controllers, providing flip, fold and all kinds of other transitions.. The repository metadata lists Objective-C as its primary language. The metadata lists the NOASSERTION license. This article stays within the project description and details documented in the GitHub repository README. - Repository: https://github.com/ColinEberhardt/VCTransitionsLibrary - Stars: 4,512 · Forks: 601 - Language: Objective-C - License: NOASSERTION - Published: 2026-08-13 · Updated: 2026-08-18 · Language: en - Canonical page: https://hysenlabs.com/projects/colineberhardt-vctransitionslibrary ## What problem it solves and who it is for Custom view controller transitions became possible in iOS 7, but building them from scratch requires implementing two distinct protocols and managing animation timing, reverse playback, and gesture handling. VCTransitionsLibrary solves this by providing a collection of pre-built animation controllers and interaction controllers that you can wire into your app. The target audience is an Objective-C developer working on an iOS 7 era app who wants a variety of visual effects, such as flip, fold, crossfade, explode, turn, cards, NatGeo, portal, cube, and pan, without writing each animation from zero. The library is particularly useful for navigation controllers, tab bars, and modal presentations, as the README shows examples for each context. It is not for someone who needs a modern, actively maintained solution or who wants to support the latest iOS versions with Swift-first APIs. ## How the architecture separates animation from interaction The core design is a clean separation between two classes: animation controllers and interaction controllers. An animation controller is responsible for performing the visual transition, while an interaction controller manages gesture-driven transitions, allowing the user to swipe or pinch to control the navigation and even cancel it mid-gesture. The README emphasizes that these are entirely independent, so you can pair any interaction controller with any animation controller. This modularity is a genuine strength, as it lets you mix gestures and effects without rewriting code. All animation controllers subclass CEReversibleAnimationController, which provides a reverse property that is used to play the animation backwards, typically for pop operations in a navigation controller. The interaction controllers are not described in detail in the provided material, but the README mentions they support swipe and pinch gestures and can be used with any animation. This separation means you can add a new animation without touching gesture logic, and vice versa. ## Getting it running: CocoaPods and manual integration The README provides two ways to incorporate the library into your project. The first is CocoaPods: add a reference to VCTransitionsLibrary to your Podfile. The second is manual file copy: copy the required files from the AnimationControllers and InteractionControllers folders into your project. There is no detailed installation command beyond that, but the steps are straightforward. To use an animation controller, you implement the appropriate delegate protocol. For present and dismiss transitions, you set the transitioningDelegate property on the view controller and return an animation controller from animationControllerForPresentedController:presentingController:sourceController: or animationControllerForDismissedController:. For navigation controllers, you implement navigationController:animationControllerForOperation:fromViewController:toViewController: and set the reverse property based on the operation, as shown in the README's code example. For tab bar controllers, you use tabBarController:animationControllerForTransitionFromViewController:toViewController: and determine the direction by comparing the indices of the view controllers. The README includes code snippets for each scenario, which makes integration concrete. ## The animation and interaction controller inventory The library includes ten named animations: Flip, Fold, Crossfade, Explode, Turn, Cards, NatGeo, Portal, Cube, and Pan. Each can be made interactive with either a swipe or pinch gesture, according to the README. The Pan transition is the most recent addition, released in version 1.5.0. The portal transition was added in 1.3.0, and cube in 1.4.0. This shows a progression of features over time, but the last release was in November 2014, indicating that the library is frozen. The README does not provide details on the visual characteristics of each animation, so you would need to look at the demo app in the TransitionsDemo folder to see them in action. The interaction controllers are not individually named in the provided material, but the README states they support swipe and pinch gestures, and they can be used with any animation controller. This is a useful catalogue for a developer who wants to experiment with different effects quickly. ## Limitations and cases where it is the wrong tool The most obvious limitation is the project's age. The last push was in November 2014, and the library is written in Objective-C, which means it does not take advantage of Swift or modern iOS APIs. If you are targeting iOS 8 or later, you might be better off using the built-in UIPercentDrivenInteractiveTransition and UIViewControllerAnimatedTransitioning protocols directly, as they are well-documented and supported. Another limitation is that the README does not mention any support for iOS 8's adaptive transitions or size classes, so the library may not work correctly with traits-based presentations. The license is listed as NOASSERTION, which is a red flag: it means the repository does not specify a clear open-source license. This could create legal uncertainty if you plan to use it in a commercial product. Finally, the interaction controllers are gesture-based, but the README does not explain how to handle conflicts with other gestures in your app, such as scroll views or edge swipes. You would need to test this yourself. ## Alternatives: writing your own or using other libraries The primary alternative is to implement your own animation controllers using the iOS 7 APIs. This gives you full control over the animation and interaction, but requires you to write the code for each effect, which is exactly what this library avoids. Another alternative is to use a more modern library like Hero, which is a Swift-based transition library that uses a declarative approach and supports iOS 8 and later. Hero focuses on view-to-view animations rather than predefined effects, and it has active maintenance. The difference in approach is that VCTransitionsLibrary provides a set of fixed animations that you drop in, while Hero lets you define transitions by specifying which views animate and how, giving more flexibility but requiring more setup. If you only need a couple of simple transitions, writing your own is often simpler than integrating a library with an unclear license. If you need many effects and are stuck on iOS 7, this library is a quick option, but you should weigh the maintenance cost. ## Maintenance and upgrade cost The maintenance cost is significant because the project is abandoned. There have been no commits since November 2014, and the last release, 1.5.0, added the Pan transition. The repository is not archived, but the lack of activity means you cannot expect bug fixes or updates for new iOS versions. If you adopt this library, you must be prepared to fork it and fix issues yourself. The code is in Objective-C, so if your project migrates to Swift, you will need to use bridging headers or rewrite the transitions. The README suggests copying files manually, which makes it easy to vendor the code, but then you own the maintenance. The license being NOASSERTION adds another layer of risk: you may not have the legal right to modify or redistribute the code without permission. Before using it, you should contact the author or check the repository for a license file, though none is visible in the provided material. For a production app, this is a serious concern, and you should consider whether the convenience of the library outweighs the lack of legal clarity and future support. ## Conclusion Adopt VCTransitionsLibrary if you are building an iOS 7+ app in Objective-C and want a ready-made set of transition animations with gesture-driven interactivity, without writing your own animation controllers. Do not use it if you target iOS 8 or later exclusively, need Swift support, or require a maintained library with a clear license. Before integrating, verify the actual license status, test each animation on your target devices, and confirm that the interaction controllers behave correctly with your navigation stack, as the project has not been updated since 2014. ## FAQ ### How do I add VCTransitionsLibrary to an Xcode project? Two ways. If you use CocoaPods, add a reference to VCTransitionsLibrary in your pod file. If you do not, copy the required files into your project directly, since the AnimationControllers and InteractionControllers folders contain all the code that is required. ### Can any interaction controller work with any animation in this library? Yes. Animation and interaction controllers are entirely independent, so any interaction controller can be wired up with any animation controller. All the animation controllers subclass CEReversibleAnimationController, which allows the animation to be played in reverse. ### Which transitions does VCTransitionsLibrary ship? Flip, Fold, Crossfade, Explode, Turn, Cards, NatGeo, Portal, Cube, and Pan. Each of them can be made interactive with either a swipe or a pinch gesture. ### How do I use one animation for both push and pop? Return the animation controller from the navigationController: animationControllerForOperation: fromViewController: toViewController: delegate method, and set the reverse flag when the operation is UINavigationControllerOperationPop. For tab bar transitions there is no operation argument, so you compare the indices of the two view controllers in the tab bar controller instead. ## Sources - [Official README](https://github.com/ColinEberhardt/VCTransitionsLibrary#readme) - [Project repository](https://github.com/ColinEberhardt/VCTransitionsLibrary) - [Release notes](https://github.com/ColinEberhardt/VCTransitionsLibrary/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/colineberhardt-vctransitionslibrary