Library / SDK
uias/Tabman avatar
uias/Tabman

Tabman: four bar areas, three areas, and should should twice

™️ A powerful paging view controller with interactive indicator bars

2,920 stars241 forksSwiftMIT

At a glance

What is it?
An iOS page view controller whose customization section enumerates four functional areas and whose advanced section then refers to three, whose transition style property is exposed on four different types and twice described with a duplicated word, whose two native UIKit bar item types cannot update dynamically, and whose repository carries a Ruby lockfile to build its documentation.
Who is it for?
Tabman is a well-factored iOS component if you want configurable bars above or below your content rather than a fixed tab bar, and the composition model is the reason to choose it: you mix and match a layout, a button set and an indicator, and you write two data sources rather than one. Read the property names against the area you are actually configuring, because the same three names appear under several areas and one of them only exists on a collection subtype.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 50 days ago.
What is it written in?
Mainly Swift, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • uias/Tabman2,920 ★ · -4
Star history
Repository2026-09-242026-11-15
uias/Tabman2.9k2.9k

-4 Stars in the last 52 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Four functional areas here, three functional areas later

The customization section is organised around a claim that a bar is made up of four distinct areas. The first is the bar's root view, described as the glue that meshes all the other areas together and as the entry point for all other customization. The second is the layout, which decides how the buttons are displayed and spaced. The third is the button, which is what the data source items turn into. The fourth is the indicator, which shows where the current page sits.

Then the advanced customization section, further down the same page, says the root view uses generics to define and serve three distinct functional areas of the bar. A generous reading is that the root view is the fourth area and serves the other three, in which case the two sentences are compatible. A less generous reading is that a reader counting areas as they scroll has been given two different numbers by the same document. Either way the page should have said so.

swift
let bar = TMBar.ButtonBar()
let tabBar = TMBar.TabBar()

One transition style, four names, should should twice

The transition style is the most-repeated property on the page, and it is the easiest to get wrong. It appears as a property of interest on the layout, on the button and on the indicator. It is also set directly on the bar in the customization example, while the very first usage example sets it on the bar's layout instead. So the first two code samples a reader meets contain the same property name applied to two different objects.

The descriptions compound it. The button's entry qualifies the name with a collection type in brackets, which means that property is not on the button itself but on a subclass for a set of buttons. And two of the three lists end with the same sentence containing the same duplicated word, once for the buttons and once for the indicator: how they should should perform transition animations.

The property lists describe each other

Each of the four areas has a short list headed as properties of interest, and the lists overlap more than the areas do. A background view property appears under the root view and again under the button, described in both cases as the type that provides background styling. A content inset property appears under the layout, where it is the inset applied to the edges of the layout, and again under the button, where it is the inset applied to the edges of the button. The parallel is exact enough to read as a template filled in per section rather than as a description of genuinely distinct behaviour.

There is one place where the template breaks usefully. The button's list names its transition style with a collection type in brackets while the layout's and the indicator's do not.. Everything else in those lists has to be checked against the generated documentation for the specific type you are holding, which is why each section links out to its own page rather than trying to be complete.

Two native bar item types, and neither updates dynamically

A bar asks for one item per page from the page data source, and the protocol that item satisfies is the library's own. The default implementation is a simple type with a title, an image and a badge value. The page also accepts two types that come with the system framework: a navigation item and a tab bar item.

Those two come with a caveat set in italics, and the caveat is a limitation rather than a style note: they are unable to support the dynamic updating of the bar when properties are set. In practice that means the convenience is real until you mutate an item after the bar has been built, at which point the bar will not reflect the change. For a bar that shows a badge or updates a title in response to application state, it is worth deciding which of the two item types you want before writing the rest of the integration.

You write two data sources and import two packages

This is a layer on top of another library rather than a standalone controller. The page credits its foundation as a separate page view controller project by the same author, and the consequence is visible in the sample code: the imports list both packages, the view controller subclasses the Tabman class, and the extension at the bottom conforms to two protocols at once, one belonging to the underlying paging library and one belonging to Tabman for its bar.

The setup sequence is four numbered steps. Build the view controller around an array of the view controllers you want. Set its data source. Create, customise and add as many bars as you want, each placed into a predefined area at the top or bottom, into a navigation item, or into a custom view with a supplied layout. Then implement the data sources. Bars can be added at any number of positions, and a repository-hosted guide covers the placement options in more detail than the page does.

One feature claim deserves attention because it changes layout without asking: the library automatically insets the contents of child view controllers.

iOS 14 with a Swift 6 toolchain, and a misspelling

The requirements are one sentence: the library needs a mobile operating system version of fourteen or above, and it is compatible with the sixth version of the language on the matching development toolchain. Those two numbers point in opposite directions, which is normal for a library trying to keep a low deployment target while building against a current compiler, but it does mean you cannot check compatibility with the minimum target alone.

The sentence also contains a misspelling of the word compatible, which is the kind of thing that survives because it is in a requirements line that nobody rereads.

The release record is more consequential. A fourth major version shipped in December 2025, a patch followed in April 2026, and before that the previous minor had been out for twenty months. So the current line is a major version roughly a year old with one patch on top, which for a component library means the major bump is recent enough that migration notes matter and old enough that the ecosystem has caught up.

A Swift package with a Ruby lockfile in it

The repository carries a package manifest, a workspace, a build settings file, a resolved dependency file and a sources directory, which is what you would expect. It also carries a Gemfile and a lockfile for Ruby, a configuration file for the documentation generator that builds the site the page links to, a file for a continuous integration linter that reviews pull requests, a release automation directory, a changelog, and an artwork directory tucked behind a leading dot so it does not clutter the listing.

The Ruby pieces are not incidental. The documentation generator and the pull request linter are Ruby tools, which is why a lockfile is committed alongside the Swift dependency resolution. And having both a package manifest and an Xcode workspace means an integrator can use the package manager or open the project..

So the release engineering around this library is considerably more considered than the requirements line suggests.

Editorial conclusion

Tabman is a well-factored iOS component if you want configurable bars above or below your content rather than a fixed tab bar, and the composition model is the reason to choose it: you mix and match a layout, a button set and an indicator, and you write two data sources rather than one. Read the property names against the area you are actually configuring, because the same three names appear under several areas and one of them only exists on a collection subtype. And budget for the fact that this is a layer on a second library, so your integration surface is the sum of both.

Frequently asked questions

What does the Tabman library do on iOS?

It is a page view controller with interactive indicator bars, built on top of the Pageboy project. The bar, its layout, its buttons and its indicator are separate components you can mix and match, it can be placed at the top, the bottom, in a navigation item or in a custom view, and it automatically insets the contents of child view controllers.

What are Tabman's requirements?

A mobile operating system version of fourteen or above, and compatibility with the sixth version of Swift on the sixteenth version of the development toolchain or newer. It is distributed through the Swift Package Manager and can be integrated from the IDE.

How many customization areas does a Tabman bar have?

The customization section names four: the root bar view, the layout, the buttons and the indicator. A later advanced customization paragraph refers to three distinct functional areas so the two counts on the page do not obviously agree.

Can I use UINavigationItem or UITabBarItem as a Tabman bar item?

Yes, both native types are accepted as bar items. The page notes in italics that they are unable to support dynamic updating of the bar when properties are set, so changing an item after the bar is built will not be reflected. The library's own TMBarItem is the default.

What is Tabman built on top of?

On Pageboy, a separate page view controller project by the same author. The usage examples import both packages, subclass the Tabman view controller, and conform to the underlying paging data source alongside Tabman's own bar data source, so an integration implements two protocols.

Official sources

  1. License: MIT
  2. Project website
  3. README
  4. Releases
  5. uias/Tabman on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/uias-tabman.svg)](https://hysenlabs.com/projects/uias-tabman)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/uias-tabman.svg)](https://hysenlabs.com/projects/uias-tabman)

Was this useful?