The unglamorous infrastructure problem every creator eventually hits
Here’s a thing nobody tells you when you start publishing across seven platforms: the tooling that actually determines whether you ship content on time isn’t the scheduling dashboard or the AI caption generator. It’s the boring plumbing underneath — the window layouts, the dock configurations, the “which monitor did Premiere open on this time” tax that quietly eats twenty minutes of every editing session. I’ve spent the last few years running social accounts for a small studio and publishing my own stuff across Instagram, TikTok, YouTube, X, LinkedIn, Facebook, Threads, and Pinterest, and I can tell you with total honesty that the single biggest productivity killer in my week is not the algorithm. It’s my desk setup forgetting itself every time my MacBook goes to sleep. That’s why Many Displays, a tiny macOS utility from indie developer Martín Acuña Lledó, caught my attention — not because it’s a social media tool, but because it solves a class of problem that every creator with a multi-monitor editing bay knows intimately, and because the way it solves it teaches something about how good utility software should behave.
What Many Displays actually does (and why it’s not a social tool)
Let me be precise about the scope, because I don’t want to oversell this as something it isn’t. Many Displays is a macOS app that remembers your window layout per combination of connected displays. The maker’s own framing is refreshingly specific: his two identical LG 4K monitors would swap places after every sleep, and every window would pile up on one of them. The root cause he names is real and well-documented in macOS circles — many monitors ship with the same EDID serial, so the OS can’t tell identical units apart, and DisplayPort monitors “disconnect” when the Mac sleeps. Many Displays tells identical monitors apart by system UUID first, then by physical port, and only falls back to position as a last resort. It fixes arrangement, resolution, rotation, and HDR before restoring windows, and it reads the window server’s list directly — the maker claims about 20 ms for hundreds of windows — rather than querying every app through Accessibility, so a busy app can’t stall it.
The pricing is $19 one-time with a year of updates, after a 14-day trial with no account required. No network, no analytics, and the source is on GitHub under the FSL, which converts to MIT after two years. That last detail matters more than it looks, and I’ll come back to it.
Why this belongs in a creator-tooling conversation at all
Fair question: why am I writing about a window manager on a blog about the creator economy? Three reasons. First, the operational reality of running multiple social accounts is that you live inside a browser with fifteen tabs, a scheduling dashboard like Buffer or Later, a design tool like Canva, a video editor like CapCut or Premiere, and an analytics tab in Metricool — and that entire stack collapses into chaos the moment your displays reshuffle. Second, the maker’s approach to distinguishing identical hardware is a genuinely interesting piece of engineering that indie tool builders in our space should study. Third, and most importantly for this audience: the category of problem Many Displays solves — state that should persist across sessions but doesn’t — is exactly the category of problem that plagues social media workflows. Your content calendar should persist. Your saved hashtag sets should persist. Your UTM templates should persist. And yet, in most tools I’ve tested, they half-persist, and you spend your mornings re-establishing context that should have been automatic.
How it differs from the incumbents you’d actually compare it to
The obvious comparison set here isn’t social tools — it’s the macOS window-management and display-utility space. The best-known name is Rectangle, the free and open-source window snapper that most power users install on day one. Rectangle is excellent at what it does — keyboard-driven window tiling — but it doesn’t solve the identical-monitor problem, and it doesn’t persist layouts per display combination. Then there’s Magnet on the Mac App Store, which is the paid, polished tiling utility a lot of people buy, and again: tiling, not persistence. For display arrangement specifically, macOS itself has tried to remember configurations, and it fails in exactly the scenarios the maker describes — identical monitors, DisplayPort sleep disconnects, docks. There are also niche tools like Display Maid that save and restore window positions, and I’ve tested tools in that family before; the recurring failure mode is that they rely on Accessibility APIs to enumerate windows, which means a single hung app can stall the whole restore, and identical monitors still confuse them.
Many Displays’ differentiator, based on the maker’s description, is the combination of three things: per-display-combination layout memory (so a three-desk setup like the one a commenter named Garrett Cassidy described gets three separate remembered layouts, and the app starts from the closest known layout the first time it sees a new setup), hardware disambiguation via UUID and port rather than position, and a window-server-level read instead of per-app Accessibility queries. My take: that third point is the one that will determine whether this is genuinely better or just differently marketed. Reading the window server directly is faster and more robust in theory, but it’s also the part most likely to break across macOS updates, because Apple’s window server internals are not a stable public API. The maker is transparent that he wants to hear about failure cases — docks, three-plus monitors, odd Spaces configs — which is the right posture for a v1 utility, but it’s also an admission that the long tail isn’t fully mapped yet.
Why the open-source licensing detail matters to operators
I want to dwell on the FSL-to-MIT licensing, because it’s the kind of decision that should influence how much you trust a small utility with your workflow. The Functional Source License means the source is public, you can inspect it, and after two years it becomes fully MIT — meaning even if the developer disappears, the community can fork and maintain it. For a $19 utility that touches your window management, that’s a meaningful hedge against abandonment. Compare that to the typical closed-source Mac utility that gets sold or quietly dies. In my experience, the tools I’ve regretted adopting are almost always the ones where I couldn’t see the code and the developer went silent. The “no network, no analytics” claim is also verifiable when the source is public, which is a trust signal you don’t get from a privacy policy alone.
What creators and social media teams can borrow from it
Here’s where I want to get opinionated, because the real value of studying a tool like this is the design philosophy you can steal for your own content operations. The maker built Many Displays because he hit a specific, recurring, low-grade annoyance and decided it was worth $19 and a GitHub repo to eliminate it. That’s the correct instinct, and it’s the opposite of how most social teams operate. Most teams I’ve worked with tolerate a dozen small frictions — the caption that has to be re-formatted for each platform, the video that has to be re-exported at three aspect ratios, the UTM string that gets rebuilt from scratch every campaign — because each friction feels too small to fix. Individually they’re nothing; collectively they’re the difference between publishing five times a week and publishing twice.
The Many Displays approach suggests a framework: identify the state that should persist but doesn’t, and build or buy the smallest thing that makes it persist. For a social operator, that looks like a saved template library for CapCut exports at 9:16, 1:1, and 16:9; a UTM builder that lives in a spreadsheet or a tool like Google Analytics’ Campaign URL Builder so you’re not hand-typing utm_source=instagram&utm_medium=social every time; a repurposing checklist that maps one long-form YouTube video into a TikTok hook, a LinkedIn carousel, an X thread, and a Pinterest pin. None of these are glamorous. All of them compound.
The “closest known layout” idea is a content strategy metaphor
The detail I keep thinking about is how the app handles a brand-new display setup: it starts from the closest layout it already knows, then remembers that one too. That’s a genuinely elegant piece of product design, and it maps almost perfectly onto how a creator should approach a new platform. When you launch on Threads or Bluesky or wherever the next thing is, you shouldn’t start from a blank page — you should start from the closest thing you already know how to do, adapt it, and then let that platform’s specific playbook accumulate. The teams that struggle on new platforms are the ones who treat each launch as a from-scratch endeavor; the teams that win port their existing muscle memory and then refine. Many Displays encodes that principle in software. Your content operation should encode it in process.
Where my judgment says it falls short
Now the balanced part, because I don’t do hype. First, the scope is narrow by design: this is a macOS-only utility for people with multiple displays, and if you’re a solo creator working off a single laptop screen, it does nothing for you. Second, the maker himself is soliciting failure reports for docks, three-plus monitor setups, and unusual Spaces configurations, which tells me the edge cases aren’t fully solved — and if your editing bay involves a dock that renegotiates display connections on every wake, you may be in the part of the long tail where it’s still being figured out. Third, the Accessibility-versus-window-server tradeoff cuts both ways: reading the window server is faster, but it’s also the kind of approach that can break silently when Apple ships a macOS update, and a $19 one-time purchase with a year of updates means you’re betting the developer keeps pace with OS changes beyond that year. The FSL-to-MIT fallback mitigates the abandonment risk, but it doesn’t eliminate the maintenance burden if the maker moves on.
Fourth, and this is the honest one: I haven’t run Many Displays myself, so everything I’ve said about its performance is the maker’s claim, not my tested result. What I can tell you from experience is that the class of tool is worth trying — I’ve lost more hours to window reshuffling than I care to admit, and I’ve paid for worse utilities. The 14-day trial with no account required is the correct way to evaluate it: install it, put your Mac to sleep ten times over a week, and see whether your layout survives. That’s the only test that matters.
Where the math breaks for social teams
If you’re a social media manager at an agency with a shared hot-desk setup, Many Displays is probably not your tool — you’re not on one machine with a stable display configuration, you’re rotating through machines and desks, and the per-combination memory assumes a consistency you don’t have. The tool shines for the indie founder or solo creator with a fixed editing bay and two or three monitors who works on the same machine every day. That’s a real audience — it’s most of the people reading this — but it’s not everyone, and I’d rather say so than pretend it’s universal.
What I’d watch / test next
Three concrete things you can do this week, whether or not you buy Many Displays. One: audit your own setup for the “state that should persist but doesn’t” problem — spend a day noting every time you re-do something you’ve done before (re-formatting a caption, re-exporting a video, rebuilding a UTM link, re-arranging windows), and pick the one that costs you the most minutes. Two: if you’re on macOS with multiple monitors, install the Many Displays trial and run the sleep test I described — ten sleep cycles, check whether your layout and windows survive, and report back to the maker if they don’t, because he’s explicitly asking for failure cases. Three: apply the “closest known layout” principle to your next platform launch — don’t start from scratch, port your existing playbook and adapt it. The tools that win in the creator economy aren’t always the flashy ones; sometimes they’re the $19 utilities that quietly give you back twenty minutes a day, and sometimes the lesson is in the design, not the purchase.
