Moe Memos: a native Swift client for a self-hosted memos server

The gap Moe Memos fills between a memos server and an iPhone

The upstream memos project is a self-hosted memo hub. It gives you an HTTP API and a web interface. What it does not give you is a native iOS application, and that is the slot Moe Memos occupies. The README describes it as a third-party client for memos and states plainly that the two projects are not affiliated. So the intended user is someone who already has a memos instance running, or who wants the same short-form, tweet-to-yourself capture habit without operating any server at all. The second mode matters more than it first appears. Moe Memos can run entirely on local on-device storage, and the README frames the choice as either a self-hosted server or local storage with no server required. That makes the app usable by people who never wanted to run Docker, a reverse proxy and a database just to jot down a thought. The feature list is deliberately narrow: write memos, tag them, pin them, search them, attach images and video, and look at a progress graph of your activity. There is no collaboration model, no shared workspace, no commenting. It is a personal capture tool with an optional sync backend, and the README's own framing, writing memos like tweeting to yourself, sets the register.

How the client talks to memos, and what happens when you are offline

The architecture is a native Swift application built on SwiftUI, using async await, with the README stating that the project keeps dependencies as few as possible. Two storage paths exist behind the same interface. In server mode the app is an API client for a memos instance. In local mode the memos live on the device. The README says the app is fully functional offline and automatically pushes data when back online, which implies a local write path that queues changes and reconciles them against the server once connectivity returns. The README does not describe the conflict resolution rules, the queue format, or what happens when the same memo is edited on two devices before either reconnects. That is a real gap in the material, and it is the kind of detail that determines whether offline mode is trustworthy for daily use. What the README does commit to is privacy: no data collection, and the local mode means there is no server to collect anything in the first place. Extended Markdown support and file uploads are listed as features, so the client is not limited to plain text blobs. The dependency-light stance is consistent with the stated goal of a minimal app optimized for a native experience, though it also means behaviour is tied closely to whatever Apple platform APIs the current release targets.

The supported memos version range is the first thing to check

This is the constraint that will decide whether Moe Memos works for you. The README states that the current version supports Memos 0.21.0 and Memos 0.27.0 to 0.30.0, and warns that memos updates may introduce breaking API changes. Note the shape of that range: 0.21.0 is supported, then 0.22.0 through 0.26.x are not listed, then 0.27.0 through 0.30.0 are. That is not a smooth compatibility window, and the README does not explain why the middle releases are excluded. For anyone running a self-hosted memos instance that has been upgraded on its own schedule, this is the single fact that determines adoption. If your server is above 0.30.0, the README recommends using Mortis, a separate project by the same author, to convert the newer memos API to the Memos 0.21.0 API, after which you re-login in Moe Memos. That is a proxy you have to deploy and maintain alongside the server. It is a workable answer, but it adds a moving part that a native client would not otherwise need, and it means the compatibility burden shifts from the app to your infrastructure.

Installing from the App Store or building it yourself

The primary installation path is the App Store. The README links a badge for Moe Memos on the App Store and states the app is available there for free. There is also a TestFlight link for the beta channel. If you prefer to build it, the README says you can build this app with Xcode and run it on your devices, and that iOS 18 or higher is required. No build flags, schemes or configuration keys are documented in the material provided, so the exact steps beyond opening the project in Xcode cannot be confirmed from what is here. Configuration of the server connection happens inside the app rather than in a config file: you point it at your memos instance and log in, and the README's Mortis instructions explicitly end with re-login in Moe Memos after the proxy is in place. There is no documented environment variable or plist key for the server URL in the material supplied. The development section describes the project's posture rather than a contributor workflow: modern Swift, SwiftUI, async await, few dependencies. Contributions are described as greatly appreciated, with no stated process.

Where Moe Memos is the wrong tool

Three cases stand out. First, if you run memos on a rolling release or track newer versions, you are outside the supported range and you will need Mortis. That is a second service to operate, and the README's recommendation to re-login after deploying it suggests the client's session and cached state are tied to the API shape it expects. Second, if you need a cross-platform client, this is not it. Moe Memos is an Apple-platform app, and the README lists iPhone and iPad with multitasking support, not Android, Windows or the web. Your memos server still serves its own web interface, but the native experience does not travel. Third, if you want a note system with structure, Moe Memos is the wrong shape. Tags, pinning and search are the organization primitives, and the README lists no notebooks, no nested folders, no backlinks, no relational links between notes. It is flat capture. The offline model is also worth flagging as an unknown rather than a limitation: the README asserts offline functionality and automatic push, but says nothing about conflict handling, so anyone syncing from two devices is trusting behaviour the documentation does not describe.

How it differs from Obsidian and from the memos web UI

The closest comparison in the self-hosted note space is Obsidian, and the difference is in where the data lives and how sync is achieved. Obsidian works on local Markdown files in a vault and treats sync as an add-on, with the community plugin ecosystem supplying most extensions. Moe Memos inverts that: the server is the optional part, and the app is the client, with a deliberately small feature set and few dependencies. Obsidian's model gives you file-level ownership and a plugin surface; Moe Memos gives you a mobile-first capture flow and an API contract with a specific server version. If you already run memos, the more direct alternative is simply the memos web interface in Safari. That requires no installation and no version matching beyond what the server itself ships, but it is a web app, not a native one, and the README's feature list (Liquid Glass, Dark Mode, Dynamic Type, iPad multitasking) is precisely the set of things a native client buys you over a browser tab. The trade you are making is convenience and platform integration against a compatibility window that the web UI does not have.

Licence, maintenance and what upgrading actually costs

Moe Memos is licensed under MPL-2.0, and the README is unusually direct about the practical consequence. It notes that while the open source licence does not prevent anyone from renaming and repackaging the app for distribution, doing so violates App Store Review Guidelines 4.1, and it welcomes apps built on the code that are meaningfully different. That is a factual statement about the distribution channel rather than a restriction the licence itself imposes, and it is worth reading carefully before planning a fork for the App Store. On maintenance, the release history shows a steady cadence: 2.0.2 in February 2026, 2.0.4 in April, 2.0.5 in July, with a push to the default branch in August 2026. The app is not archived. The upgrade cost sits mostly on the server side, not the client. Because the README pins support to specific memos versions and warns about breaking API changes, every memos upgrade is a potential client upgrade or a Mortis deployment. That is the recurring tax: a native client that is pleasant to use but whose compatibility is defined by someone else's release schedule. The README's own recommendation to use Mortis above 0.30.0 is the clearest signal that the author expects this friction to continue rather than disappear.

Editorial conclusion

Adopt Moe Memos if you already run a memos server in the 0.21.0 or 0.27.0 to 0.30.0 range, or if you want a local-only memo app on iOS 18 and never intend to sync. Do not adopt it if your server tracks memos main, because the API compatibility window is explicit and the documented remedy is to put Mortis in front of the newer API and log in again. Before installing, check your server version with the memos settings page, and if it is above 0.30.0, read the Mortis repository first to confirm the conversion path still matches your deployment.

Official sources

1. License: MPL-2.0
2. mudkipme/MoeMemos on GitHub
3. Project website
4. README
5. Releases