# EasyTableView: the pre-collection-view answer to a partial-screen table

> EasyTableView is an Objective-C UIKit class that gives you a table view which fills only part of the screen and scrolls either vertically or horizontally, a problem that UICollectionView later made moot, and the README says so directly.

**alekseyn/EasyTableView** — Horizontal and vertical scrolling table views for iOS

- Repository: https://github.com/alekseyn/EasyTableView
- Stars: 575 · Forks: 149
- Language: Objective-C
- License: BSD-3-Clause
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/alekseyn-easytableview

## Two problems, one class, both dated

The README is unusually direct about its own history, and the first line of the description says it was written before UICollectionView became available, while noting that developers may still prefer EasyTableView for its simplicity. That single sentence frames the whole project. The class was created to address two concerns. The first is the ability to have a table view, horizontal or vertical, that only partially fills the screen, because UITableViewController, as Apple documents it, requires table views that fill the whole screen. The second is horizontal table views, since table views were designed to be vertical only. The solution to the first problem is that EasyTableView acts as the controller for an embedded table view and exposes a subset of table view functionality through its own delegate methods. The solution to the second is that it rotates the table view and then reverse-rotates the table view cells. The audience is an Objective-C iOS developer working in that era, and the honest audience today is much smaller.

## Horizontal scrolling is a rotation trick

The rotation approach is the interesting part of the design, and it explains both the strengths and the awkward edges. Rotating the table view and reverse-rotating the cells means the same table view machinery handles both orientations, so there is one implementation of data source, delegate, cell reuse and scrolling rather than two. What it costs is that the geometry has to be reasoned about in rotated coordinates, which is exactly where the known limitation about height comes from. A horizontal EasyTableView will correctly auto-resize its overall length, the width along the scroll axis, but it will not necessarily correctly auto-resize its height. The README mentions the alternative of subclassing UIScrollView to get horizontal scrolling, and says the author wanted one simple, common interface for creating both vertical and horizontal EasyTableViews. That is a real design preference rather than an accident, and it is the reason the class exists as one thing rather than two.

## Dropping the class into a project

Adoption is simple in the way of an older iOS library. The README says that to use EasyTableView in your own project, all you need to include are the following files.

```
EasyTableView.h
EasyTableView.m
```

Two files, no dependency, and the project is also published through CocoaPods with a podspec at the top level, EasyTableView.podspec, alongside an Xcode project, EasyTableView.xcodeproj. The top level entries show the shape of the demo: a Classes/ directory, a UI/ directory, Images/, main.m, an Info.plist and a prefix header, plus a .gitignore and the LICENSE. The demo is intended to be run on an iPad only, though the README notes there is no reason EasyTableView could not be used on an iPhone, which is a fair statement for a class that is really a scroll view with cells in it.

## The delegate surface is three methods, and two of them are optional

The API is small enough to describe in a sentence, and the README points at the code for the details. To create an instance you look at two setup methods, setupHorizontalView and setupVerticalView, and then use one of two initialisers, one taking a frame and a cell height for a vertical table, the other taking a frame and a cell width for a horizontal one. The delegate protocol requires two methods, one returning the number of rows in a section and one returning the cell for a row at an index path. A third method, returning the number of sections, is only required if you use multiple sections. For a storyboard-driven setup, the README points at FlipsideViewController.m. That is the whole surface, and it is worth noting how much of the standard table view behaviour is exposed as a subset rather than the full delegate, since the class presents itself as exposing a subset of table view functionality with its own delegate methods.

## Swipe to delete arrived in 2.1

The release notes at the top of the README tell you what changed and when, and they are the fastest way to understand the current API. EasyTableView 2.1, dated May 1, 2017, extended the API: swiping a table view cell in a perpendicular direction to the normal scrolling direction of an EasyTableView drags the cell out of the EasyTableView, and if the touches end with the cell away from the EasyTableView it will be deleted, otherwise it animates back to its normal position. The README points at EasyTableViewController for an example. The 2.0 release on January 7, 2016 is flagged with an IMPORTANT NOTE saying the API changed on January 6, 2016 and that consumers prior to that date may find the update breaks their existing projects. That warning is the clearest signal about the maturity of the library, since a major version bump that breaks existing projects is normal for a young 2010-era codebase, but it does mean the version numbering tells you very little about compatibility.

## Where EasyTableView is the wrong choice

The reasons not to adopt it are structural and will not change. First, the problem it solves has been solved properly since UICollectionView arrived, and the README says so in its own opening description, so choosing EasyTableView today means choosing an obsolete answer to a solved problem on the grounds of simplicity, which is a defensible reason in a small legacy codebase and an odd one in a new project. Second, it is Objective-C, so a Swift team would be adding a bridging layer for a control that Swift UIKit already provides in a modern form. Third, the known limitations are real and unaddressed: auto-layout is not supported, horizontal height does not auto-resize correctly, and the demo has a flaky data path, since loading the Flickr catalog will sometimes fail due to JSON parsing errors. The alternative worth naming is UICollectionView with a compositional or list layout, which handles partial fills, horizontal scrolling and auto-layout natively. The honest reading is that EasyTableView is a well-documented artifact of a specific period of iOS development, useful mainly as a reference implementation and a source of the rotation trick for horizontal table views.

## Conclusion

Adopt EasyTableView only if you are maintaining Objective-C code from the pre-collection-view era that needs a partially filled table, since the two problems it solved are now better handled by UICollectionView. Do not start new work on it, because the author notes it predates UICollectionView and that developers may still prefer it for its simplicity, which is a statement about a specific moment in iOS development rather than an endorsement today. Verify first that your project targets a toolchain where Objective-C is still viable, and note that the last release was 2.1 from May 2017 and auto-layout is not supported.

## FAQ

### What problem does EasyTableView solve?

Two. It allows a table view that only partially fills the screen, which UITableViewController does not support, and it allows horizontal scrolling table views, which table views were not designed for. The class acts as the controller for an embedded table view and exposes a subset of table view functionality through its own delegate methods.

### How do I add EasyTableView to an Objective-C project?

The README says all you need to include are EasyTableView.h and EasyTableView.m. The project is also published on CocoaPods with a podspec, and the repository contains an Xcode project, a Classes directory, a UI directory and the demo sources.

### Which delegate methods must I implement for EasyTableView?

Two are required, one returning the number of rows in a section and one returning the cell for a row at an index path. A third, returning the number of sections, is required only if you use multiple sections.

### What are the known limitations of EasyTableView?

A horizontal EasyTableView auto-resizes its overall length but not necessarily its height, loading the Flickr catalog sometimes fails due to JSON parsing errors, and auto-layout is not supported. The last release was 2.1, dated May 1, 2017.

## Sources

- [alekseyn/EasyTableView on GitHub](https://github.com/alekseyn/EasyTableView)
- [Issues](https://github.com/alekseyn/EasyTableView/issues)
- [License: BSD-3-Clause](https://github.com/alekseyn/EasyTableView/blob/master/LICENSE)
- [README](https://github.com/alekseyn/EasyTableView/blob/master/README.md)

---

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