Introduction

If you want a side-swipe menu on iOS, the best implementation is usually a custom container view controller rather than trying to bolt gesture code onto unrelated screens. The container owns two child controllers: the menu and the main content. That keeps gestures, animation, and state in one place instead of scattering them across the app.

Start With the Right Architecture

A side menu is not just an animation. It affects view hierarchy, gesture routing, screen transitions, and state restoration. That is why the cleanest design is a container view controller.

The high-level structure is:

• one menu controller behind the content
• one content controller in front
• a pan gesture on the content layer
• a small state machine that tracks open or closed

This is much easier to reason about than pushing side-menu behavior into every screen individually.

A Basic Container Controller

Here is a simplified Swift sketch:

1import UIKit
2
3final class SideMenuContainerViewController: UIViewController {
4    private let menuWidth: CGFloat = 280
5    private let menuViewController: UIViewController
6    private let contentViewController: UIViewController
7    private var isMenuOpen = false
8
9    init(menu: UIViewController, content: UIViewController) {
10        self.menuViewController = menu
11        self.contentViewController = content
12        super.init(nibName: nil, bundle: nil)
13    }
14
15    required init?(coder: NSCoder) {
16        fatalError("init(coder:) has not been implemented")
17    }
18
19    override func viewDidLoad() {
20        super.viewDidLoad()
21
22        addChild(menuViewController)
23        menuViewController.view.frame = CGRect(x: 0, y: 0, width: menuWidth, height: view.bounds.height)
24        view.addSubview(menuViewController.view)
25        menuViewController.didMove(toParent: self)
26
27        addChild(contentViewController)
28        contentViewController.view.frame = view.bounds
29        view.addSubview(contentViewController.view)
30        contentViewController.didMove(toParent: self)
31
32        let pan = UIPanGestureRecognizer(target: self, action: #selector(handlePan(_:)))
33        contentViewController.view.addGestureRecognizer(pan)
34    }
35
36    @objc private func handlePan(_ gesture: UIPanGestureRecognizer) {
37        let translation = gesture.translation(in: view).x
38
39        switch gesture.state {
40        case .changed:
41            let baseX = isMenuOpen ? menuWidth : 0
42            let newX = min(max(baseX + translation, 0), menuWidth)
43            contentViewController.view.transform = CGAffineTransform(translationX: newX, y: 0)
44        case .ended, .cancelled:
45            let shouldOpen = contentViewController.view.transform.tx > menuWidth / 2
46            setMenu(open: shouldOpen, animated: true)
47        default:
48            break
49        }
50    }
51
52    func setMenu(open: Bool, animated: Bool) {
53        isMenuOpen = open
54        let targetX = open ? menuWidth : 0
55
56        let changes = {
57            self.contentViewController.view.transform = CGAffineTransform(translationX: targetX, y: 0)
58        }
59
60        if animated {
61            UIView.animate(withDuration: 0.25, animations: changes)
62        } else {
63            changes()
64        }
65    }
66}

This is not production-ready by itself, but it demonstrates the correct ownership model.

Why a Container Works Better

A container controller gives you a single place to handle:

• opening and closing the menu
• dimming overlays
• status bar coordination
• gesture conflicts
• swapping the current content screen

For example, when the user taps a menu item, the container can replace the front content controller cleanly without each screen needing to know how the menu works.

Gesture Handling Matters More Than the Animation

The animation is usually the easy part. The harder part is deciding when the pan gesture should begin and when it should not.

For example, if the front screen has a horizontal scroll view, a side menu pan gesture can fight with that scroll gesture. In real apps you often need UIGestureRecognizerDelegate rules to avoid accidental opens.

A common policy is:

• allow edge-origin pans to start the menu when closed
• allow pan anywhere on a dimmed overlay when open
• avoid stealing gestures from inner scroll views when possible

That produces a more predictable feel than treating every horizontal drag as a menu interaction.

Manage the Visual Layers Intentionally

Most good side menus use a few simple visual tricks:

• content slides horizontally
• the menu sits behind it
• a dimming view appears over content when the menu is open
• the dimming view closes the menu on tap

For example, adding a dimming view:

let dimmingView = UIView(frame: view.bounds)
dimmingView.backgroundColor = UIColor.black.withAlphaComponent(0.2)
dimmingView.alpha = 0

Animate its alpha together with the content translation and the interaction feels much more deliberate.

Consider Whether You Should Use This Pattern At All

A side-swipe menu is technically fine, but it is not always the best navigation choice. Hidden navigation can make important destinations harder to discover. On modern iOS, many apps are better served by:

• tab bars
• split views on larger screens
• context-specific action menus

So the best way to build a side menu is often to first confirm that the app really needs one.

Common Pitfalls

The biggest pitfall is implementing the menu separately in every screen rather than centralizing it in a container controller. That quickly becomes brittle.

Another common issue is poor gesture conflict handling. A menu that opens while the user is trying to scroll horizontally feels broken even if the animation is smooth.

People also often load too much into the menu itself. The side menu should usually contain navigation choices, not heavy interactive content competing with the main screen.

Finally, avoid relying on a third-party library unless it actually saves maintenance for your app. A simple custom container is often easier to own long-term than a generic menu framework.

Summary

• The best foundation is usually a custom container view controller.
• Keep the menu behind the content and animate the content layer horizontally.
• Treat gesture handling and state management as first-class design problems.
• Add a dimming overlay and clear open or close behavior for better UX.
• Use a side-swipe menu only if hidden navigation is truly the right fit for the app.