TableFlip - Markdown Table Editor for macOS

The Context

TableFlip emerged from a personal frustration: editing tables in Markdown is painful. As someone who writes technical documentation regularly, I needed a visual table editor that respected Markdown’s simplicity while providing a spreadsheet-like interface.

Released in 2017 and continuously maintained, TableFlip represented a significant step up in complexity from Word Counter. This was a document-based application (NSDocument) that needed to handle file changes on disk, multiple windows, and much more sophisticated user input – far beyond Word Counter’s isolated operation with occasional events. I wanted to apply everything I’d learned, but do it better, faster, and more robustly.

Technical Challenges

Bidirectional Markdown Parsing

• Parse Markdown tables while preserving formatting quirks
• Become a layer on top, a companion to the user’s actual text editor, not a replacement
• Generate clean Markdown that works with various parsers (CommonMark, MultiMarkdown, GFM)
• Handle edge cases like pipes in cells, escaped characters, and malformed tables

Modular Architecture at Scale

Building on the modular approach I developed with Word Counter, TableFlip took this even further with multiple framework targets within the app itself. Each major feature lived in its own framework:

• Table parsing and generation engine
• Cell editing components
• File format handlers
• UI components and controls

This extreme modularity meant I could develop and test each piece in complete isolation, often building UI components as standalone mini-apps before integrating them. This “late integration” philosophy ensured true independence and reusability.

Unidirectional Data Flow

• Implemented ReSwift for predictable state management
• Created a functional core that treats table transformations as pure functions
• Maintained undo/redo stack through immutable state transitions

Document-Based Complexity

As an NSDocument-based application, TableFlip had to handle:

• Live file change monitoring and conflict resolution
• Multiple document windows with independent state
• Auto-save and versioning integration
• Coordinated file access with other editors
• Different file formats, and making the file picker behave

File Format Support

• CSV import/export with encoding detection
• LaTeX table generation for academic users
• TSV and other delimited formats

Team Dynamics

For the first seven years (2016–2023), TableFlip was purely a solo effort. These years weren’t about reinventing my workflow but about accelerating development and performing at higher standards, in a more complex setting than my previous app.

Then in late 2023, I had the opportunity to bring in Marin Todorov when he was between jobs. I’d always enjoyed Marin’s work and personality, so when the timing aligned, I hired him to help with features and updates I couldn’t attend to while deep in The Archive development.

This was significant: it was one of the few times I hired someone and paid them out of my own pocket to work on my apps. The collaboration was a joy – Marin could find his way around the codebase easily, understood the architecture, and genuinely enjoyed working with it. The dynamic was effortless; things just happened on their own without friction, and since he’s such a Markdown nerd, he came up with the weirdest of ideas for the future.

Beyond just getting features shipped, this validated years of architectural decisions. When an experienced developer like Marin tells you the codebase is a joy to work with, you know the modular approach paid off.

Personal Reflections

TableFlip was my first exploration of unidirectional data flow architecture. Coming from MVVM, ReSwift felt revolutionary – everything became easier to track, features easier to add, and the whole app more predictable and understandable. With my focus on maintainable software, this was a win.

The project also taught me about finding and serving a niche. TableFlip isn’t for everyone, but for those who need it, it’s indispensable. This focused approach made marketing easier and support manageable.

But perhaps the most validating moment came when Marin joined the project. His genuine enjoyment working with the codebase – and I know he wouldn’t have lied to spare me – confirmed that all those years of careful modular architecture, and the occasional slip into imperfection, weren’t just academic exercises. The maintainability and clarity he experienced proved that good architecture matters, especially when you’re not the only one touching the code.

Impact

TableFlip has become an essential tool for:

• Technical writers managing documentation
• Researchers organizing data
• Note-takers making overviews in their favorite editors
• Developers creating README files
• Students working on academic papers

The app proved that even simple, focused tools can find a niche on the Mac platform.

More importantly, the successful collaboration with Marin validated my architectural philosophy. The fact that an experienced developer could jump in, be productive immediately, and genuinely enjoy the experience proved that investing in clean, modular architecture pays dividends – not just for solo development, but for sustainable software that others can understand and extend. This experience gave me confidence that my apps could outlive my direct involvement if needed.