# AutoScrollLabel scrolls a clipped UILabel the way a music player scrolls a track title

> AutoScrollLabel is a small Objective-C and Swift UIKit component that makes a UILabel scroll its own text when the text does not fit, with edge fading, speed control, a pause interval and configurable scroll direction. It suits iOS and tvOS developers who want the marquee behaviour of a track title without writing the animation, and it is a drop-in view rather than a framework.

**cbess/AutoScrollLabel** — Provides marquee like UILabel scrolling, think Music.app track title scrolling. For Obj-C & Swift.

- Repository: https://github.com/cbess/AutoScrollLabel
- Stars: 518 · Forks: 105
- Language: Objective-C
- License: MIT
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/cbess-autoscrolllabel

## What the component is, in one property list

AutoScrollLabel is described as a UILabel with auto scrolling for text that may be clipped by the view, providing edge fading, speed adjustment, scroll direction and more. The comparison the README offers is the useful one: think Music.app track title scrolling.

That reference point settles the behaviour. A track title in a music player does not scroll continuously, and it does not scroll at a constant rate from the moment it appears. It sits still, it waits, and then when the text is too long for the display it travels across, disappears at one edge and reappears at the other, and after a pause it comes round again.

The README's own description of the effect is that the text may be clipped, but now it will be scrolled, which is the important detail about the design. The scrolling is conditional on the text not fitting. A label with short text behaves like an ordinary label, and the sample in the README reflects that with a textAlignment setting that centers text when no auto-scrolling is applied.

The package supports Objective-C and Swift, and the repository is small in the way a single-component library should be. There is a CBAutoScrollLabel directory holding the component itself, an AutoScrollLabelDemo directory with the demo app and the screenshots referenced in the README, a Package.swift for Swift Package Manager, and a LICENSE.txt. The primary language is recorded as Objective-C, with the repository topics covering marquee, objective-c, swift and uilabel.

The stated platform support is iOS 12, tvOS 12 and greater.

## The tunable properties and what each one actually controls

The README's usage example is the best documentation of the API, because every property is set with a comment explaining what it does.

```objc
autoScrollLabel.text = @"This text may be clipped, but now it will be scrolled.";
autoScrollLabel.textColor = [UIColor systemBlueColor];
autoScrollLabel.labelSpacing = 35; // distance between start and end labels
autoScrollLabel.pauseInterval = 3.7; // seconds of pause before scrolling starts again
autoScrollLabel.scrollSpeed = 30; // pixels per second
autoScrollLabel.textAlignment = NSTextAlignmentCenter; // centers text when no auto-scrolling is applied
autoScrollLabel.fadeLength = 12.f; // length of the left and right edge fade, 0 to disable
```

Six of those lines are the interesting ones. labelSpacing is the distance between the start and end labels, which is the gap the text travels across when it wraps around, so a larger value gives a longer dead zone between the end of one pass and the beginning of the next. pauseInterval is the number of seconds of pause before scrolling starts again, and it is the property that produces the music player feel, since a scroll that repeats instantly reads as a glitch rather than as a title reel.

scrollSpeed is in pixels per second, so the same value produces different apparent speeds on different screen densities, and on a large iPad label it will look slower than on a phone with the same setting.

fadeLength is the length of the left and right edge fade, and 0 disables it. This is the property that makes the effect look deliberate, because a label whose text simply vanishes at the edge looks broken while one that fades out looks like it is passing behind something.

textAlignment is worth reading carefully, since the comment limits it: it centers text when no auto-scrolling is applied. So the alignment property governs the resting state, and the scroll takes over once the text overflows.

The feature list also names scroll direction as one of the provided behaviours, though the example does not set it, so the default direction and the property name for changing it are not spelled out in the README.

## Installing through Swift Package Manager

Installation is the Swift Package Manager, and the README gives both the Xcode route and the manifest route.

In Xcode you choose File > Add Package Dependencies and enter the repository URL:

```
https://github.com/cbess/AutoScrollLabel.git
```

Or you add it to the dependencies of your Package.swift:

```swift
dependencies: [
    .package(url: "https://github.com/cbess/AutoScrollLabel.git", commit: "<HASH>")
]
```

Then you add "AutoScrollLabel" to your target's dependencies.

The manifest snippet uses a commit rather than a version range, which is worth noticing. Pinning by commit hash is the reproducible choice, and for a component like this it is a sensible default because the library has a version numbering scheme where v0.5.0 is the current release and older tags such as v0.4.5 and v0.4.4 exist, so you can pin either way.

What the README does not mention is CocoaPods or Carthage. There is no Podspec in the repository listing and no Carthage support described, so if your project integrates dependencies through CocoaPods you will need to vendor the source or add it through the package manager, and that is a difference from most UIKit components of this age.

There is also no documentation of a manual installation route. The repository root is small, with just the .gitignore, the demo directory, the CBAutoScrollLabel directory, the LICENSE.txt, the Package.swift and the README, so dragging the component into a project is technically possible, but the README points at the package manager instead.

## Importing and using it from Objective-C and Swift

The usage section gives the import for each language, which is the minimal amount of information needed to get started.

For Objective-C it is a module import:

```objc
// objc
@import AutoScrollLabel;
```

And for Swift:

```swift
// swift
import AutoScrollLabel
```

The Objective-C form is the one that tells you something about the design. The at-sign import means the component is exposed as a Clang module, which is what the Swift Package Manager produces for Objective-C targets, and it also means the Objective-C and Swift APIs are the same object rather than a wrapper. A Swift caller gets the same class the Objective-C caller gets, with the same properties and the same names.

That is worth contrasting with the older approach to this problem. The usual manual solution to a scrolling label is to put a UILabel inside a UIScrollView and animate the scroll view's content offset, usually with a timer or a display link, and then handle the pause, the wrap-around and the reset yourself. Every project that needs this writes that loop again, and every one of them gets the pause timing and the wrap-around slightly wrong at first.

The real world use section names two apps built with it, the Sola Tunes iOS App and VerseCloud, both listed as free on the App Store. Two independent shipping apps is some evidence that the component behaves in production, though the README does not describe anything about their use of it.

## Version history, and the platform floor that shifted

The release history shows a component that sat still for a while and then got modernised.

The listed releases are v0.4.4, described as Modernize lib and sample app, from 2017-02-18; v0.4.5, described as iOS 13 ready, from 2019-09-20; and v0.5.0, described as Modernized for iOS 27+, from 2026-10-11.

That is a two year gap and then a seven year gap, which is the profile of a small component maintained by one person in between other work. The last push to the repository was on 2026-10-11, the same day as the v0.5.0 release, so the current work is in the newest release.

There is a small inconsistency in the platform story that you should notice. The README's Requirements line says iOS 12, tvOS 12 and greater, while the v0.4.5 release note says iOS 13 ready. Those two statements do not agree, and the README was not necessarily updated alongside the release notes. The safe reading is that the current version requires at least iOS 13, and that the README's iOS 12 line is stale.

That kind of drift is normal in a README that is not regenerated from the manifest, and it is worth checking against the Package.swift in the repository if your project has to support iOS 12.

The licence is MIT, copyright Christopher Bess, and the LICENSE.txt file at the repository root carries the terms. MIT is about as permissive as it gets for a UI component, so there is no obligation on a project that embeds it beyond keeping the notice.

## Where AutoScrollLabel is the wrong choice

There are cases where this component does not apply, and it is worth being clear about them.

The first is multi-line text. Everything documented here is about a single line of text travelling horizontally. A label with several lines needs the text to move vertically, or needs a different treatment entirely, and the README describes no behaviour for it.

The second is accessibility. A screen reader announcing a moving label is a problem that no marquee component in this family has solved well, and the README says nothing about VoiceOver, about accessibility labels, or about what happens to the announced text while it scrolls. If your app has accessibility requirements, this is the gap you will have to design around.

The third is the localisation case where the text changes. The behaviour here assumes a stable string that is longer than the label. A label whose text changes on a timer, or changes in response to a network response, will need the scroll restarted or reconfigured, and the README does not describe an API for that.

The fourth is iOS 17 and later design. The v0.5.0 release describes itself as modernised for iOS 27+, but the feature set remains the classic marquee: a text that slides. If you want the current system behaviour of a truncated title that expands on interaction, that is a different pattern and the README does not offer it.

For comparison, the alternatives differ in kind. Building it yourself with a UIScrollView and a CADisplayLink gives you exactly the behaviour you want and full control over timing, but it is the loop every project rewrites. A collection view cell with a truncation mode and a timer gives you the same visual result with more machinery, and it handles dynamic content because the cell manages its own layout. The system text effects for a label with a line break or a tail truncation give you a static truncated title with no movement at all, which solves the readability problem but not the marquee one.

AutoScrollLabel is the smallest option that gives you the moving title without writing the loop, and that is a reasonable trade for a component whose whole purpose is one effect.

## Conclusion

Adopt AutoScrollLabel if you need a UILabel to scroll its own text when the text is clipped, since the component handles the repeating scroll, the pause between passes and the edge fade rather than leaving you to build a CADisplayLink loop, and it installs cleanly through Swift Package Manager. Do not adopt it if you need multi-line scrolling or accessibility announcements of the moving text, since the README documents only the single-line properties and says nothing about either. Before you build, check the platform floor for your own project, because the README states iOS 12 and tvOS 12 and greater while the release notes describe v0.4.5 as iOS 13 ready, and set fadeLength to 0 if the fade conflicts with your design. The licence is MIT, copyright Christopher Bess, the newest release is v0.5.0 from 2026-10-11, and the last push was on 2026-10-11.

## FAQ

### What does AutoScrollLabel do?

It is a UILabel with auto scrolling for text that may be clipped by the view. It provides edge fading, speed adjustment, scroll direction and other controls, and the README compares the effect to Music.app track title scrolling.

### How do I install AutoScrollLabel in an iOS project?

Through Swift Package Manager. In Xcode choose File > Add Package Dependencies and enter the repository URL https://github.com/cbess/AutoScrollLabel.git, or add the package to the dependencies of your Package.swift with a .package(url:commit:) entry, then add "AutoScrollLabel" to your target's dependencies.

### Which properties control the scrolling behaviour of AutoScrollLabel?

labelSpacing is the distance between the start and end labels, pauseInterval is the seconds of pause before scrolling starts again, scrollSpeed is in pixels per second, and fadeLength is the length of the left and right edge fade, with 0 disabling it.

### What platforms does AutoScrollLabel support?

The README states iOS 12, tvOS 12 and greater. The release notes describe v0.4.5 as iOS 13 ready, so the README's platform line appears older than the current release, and v0.5.0 from 2026-10-11 is described as modernised for iOS 27+.

### Can I use AutoScrollLabel from Swift?

Yes. The Swift import is import AutoScrollLabel, and the Objective-C import is @import AutoScrollLabel, so both languages use the same class rather than a Swift wrapper around it.

### What licence is AutoScrollLabel released under?

MIT, copyright Christopher Bess, with the terms in LICENSE.txt at the repository root. The latest release is v0.5.0, described as modernized for iOS 27+, published on 2026-10-11.

## Sources

- [cbess/AutoScrollLabel on GitHub](https://github.com/cbess/AutoScrollLabel)
- [Issues](https://github.com/cbess/AutoScrollLabel/issues)
- [License: MIT](https://github.com/cbess/AutoScrollLabel/blob/master/LICENSE)
- [README](https://github.com/cbess/AutoScrollLabel/blob/master/README.md)
- [Releases](https://github.com/cbess/AutoScrollLabel/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/cbess-autoscrolllabel