# IdeaMemo: a Compose card note that syncs to your own WebDAV

> IdeaMemo is a small Android note-taking application written with Jetpack Compose, built around a flash-note card metaphor, tagged by hashtag, with a local database and an optional upload to a WebDAV server you control. It is GPL-3.0, published on Google Play and built by one person.

**ldlywt/IdeaMemo** — A Beautiful Memo App written with Jetpack Compose.        开源Android闪念笔记App。

- Repository: https://github.com/ldlywt/IdeaMemo
- Website: https://play.google.com/store/apps/details?id=com.ldlywt.note
- Stars: 1,165 · Forks: 166
- Language: Kotlin
- License: GPL-3.0
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/ldlywt-ideamemo

## A quick record app built around a card

IdeaMemo is a lightweight Android note-taking application written with Jetpack Compose, and the description calls it a quick record app. The Chinese README describes it as an open source Android flash-note app, and that second phrase is the more accurate one for what the software does.

The feature list in the README is short, and each line is a design position rather than a capability list.

Privacy first is the first, and it is stated as a guarantee: no need to apply any permissions, and all runtime data is firmly stored in your local database or can be uploaded to your own WebDAV private cloud. That is an unusual claim for an Android application, because the platform convention is that a notes app asks for storage or photo permissions, and the claim here is that it does not.

Simplicity and cleanliness comes next. Notes are indexed by `#TAG`, and the app supports mixed text and graphics to record and organise sudden inspirations. The last clause of that line is a limitation stated by the author: as a card note, it is not recommended to record too long text. So the unit of content is a card, and a card is short by design.

Review at any time is the third. The app supports a calendar view, a heatmap and a random walk to review notes, which is a set of three quite different answers to the same question, which is what happens to the notes you wrote six months ago and never read again.

The rest of the list is about the project rather than the software. The code is open source on GitHub, the app is free to use with all features and no content fees, and the author says IdeaMemo is always in use by itself and will be continuously updated.

The project is GPL version 3.0, the primary language is Kotlin, the default branch is `master`, and the last push was on 2026-10-18. The recent releases are v3.1.1 from 2026-08-16, v3.1.0 from 2026-07-26 and v3.0.0 from 2026-05-08.

## Where the notes live, and what that costs you

The storage model is the part of the application that determines what it can and cannot do, so it is worth spelling out.

There is a local database, and that is where the runtime data lives by default. The application asks for no permissions, which means it is not reading anything outside its own sandbox and is not asking the user to grant access to shared storage. On Android, a notes app that needs no permission can keep everything in its own private directory, and the user never sees a system dialog.

The alternative is an upload to your own WebDAV private cloud. WebDAV is the protocol behind most self-hosted file stores, and the point of using it is that the destination belongs to the operator, not to the app vendor. There is no account to create with a company, and no data leaves the user's own infrastructure unless the user puts it there.

That choice has a consequence. A user who wants their notes on a second device has to have somewhere to put them, and the application offers exactly one such place, a WebDAV server the user runs or rents. There is no built-in sync service, no free cloud tier and no account system, which is the same privacy posture that produces the awkwardness. A user with no WebDAV server has a local database and no way to move it, and the GitHub releases are there for people who would rather sideload the application and manage the data themselves.

For a note-taking app this is a coherent design rather than a limitation of effort, and it is the reason the permission claim in the feature list is possible. An application that talked to a vendor's server would have to authenticate, and an application that talked to a local file system would have to ask for a permission. The one that keeps everything in its own sandbox asks for neither.

## Tags, cards and the limit on long text

The organisation model is a hashtag, and the content model is a card with images in it, and the two together explain what the application is good at and what it is bad at.

Indexing by `#TAG` means the tags are part of the note text rather than a separate field. A note carries its own categories inline, which makes writing fast, because capturing a thought and classifying it is one action rather than two, and it makes the structure of the note visible when you read it later. The cost is that tags are not a controlled vocabulary, so `#idea` and `#Idea` are two tags, and a collection of notes over a year accumulates near-duplicates.

The card format with mixed text and graphics is the other half. A note can hold an image as well as text, which suits the flash-note use case, where a photograph of a whiteboard or a screenshot is the note. The author is explicit that the card is not the place for long text, and that is a constraint rather than a missing feature: a card interface, with a fixed size and images inside it, is a poor container for a paragraph of prose, and stretching the layout to fit would undo the compactness that makes the format good.

The review features then close the loop. A calendar view answers when did I write things, the heatmap shows the density of writing over time, and the random walk throws up a note you have not seen in a while, which is the mechanism for the notes that would otherwise be written and lost.

Together they make a coherent position: quick capture, tagging as you type, and multiple ways of resurfacing what you wrote. It is a system for the person who writes a lot of short things and reads them rarely.

## Two distribution channels and a version line that moves quickly

The application is distributed in two ways, and the difference between them matters for a project that is not on the Play Store in every country.

The first is Google Play, where the store listing is the homepage of the project. The second is the GitHub releases page, which carries the binaries for people who would rather install the application themselves. For an open source Android application that is a conventional pair, and the second channel is the one that matches the licensing.

The version line is worth reading. Version 3.0.0 came on 2026-05-08, 3.1.0 on 2026-07-26, and 3.1.1 on 2026-08-16, which is three releases in a little over three months, with the patch release three weeks after the minor one. The project is on a `master` branch rather than a `develop` branch, and the repository has a conventional Gradle layout with `app/`, `build.gradle.kts`, `settings.gradle.kts`, `gradle.properties` and the Gradle wrapper, plus an `.idea/` directory checked in.

The author's own statement about the pace is the feature list line that says IdeaMemo is always in use by itself and will be continuously updated, and the thanks section repeats the point: this project was created by Compose, and the power of one person is limited, with pull requests welcome. That is a candid description of a project maintained by one developer who uses the application daily, and it is a reasonable thing to weigh when you decide whether to depend on it.

The contribution guidance is unusually specific in one place. Feel free to contribute code, but please do not mention simple fix code, and the reasoning is implicit in the rest of the list: share ideas and suggestions as issues, report bugs with as much detail as possible, and enjoy the app.

## AI translations and a borrowed codebase

Two statements in the README deserve to be read rather than skipped, because they are the kind of thing that a user discovers later.

The first is about localisation. Multi-language translation is done by AI, there may be errors, please point them out. The repository carries a Chinese README alongside the English one, and the translations into the other languages are machine produced, which is a reasonable trade for a one-person project and a poor one for a user who relies on a specific term in a specific screen to be right.

The second is about the code itself. The thanks section says the project was created by Compose, that some of the project's code is derived from excellent open-source projects, and it names them: ReadYou, MoeMemosAndroid, Animius, SaltUI and memos. For a GPL-3.0 application this is a coherent position, since the licence is copyleft and the derivations are attributed. The practical consequence for a reader is that the codebase is not a single author's style throughout, and that the features of the projects it draws on, particularly around the interface and around the note-taking model, will be recognisable in places.

The licence itself is the GNU GPL version 3.0, held by IdeaMemo, and it is the licence that the two distribution channels are consistent with: a Play Store application under GPL terms is unusual but not unusual for a self-published open source app, and the GitHub releases are the plain way for the source and the binary to travel together.

## Where IdeaMemo is the wrong tool

The application does one thing well and the boundaries are visible in the README, which is unusual honesty for a project listing its own features.

The first boundary is length. A card is not a page, and the README says the app is not recommended for recording long text. Someone who wants a journal, a blog post in progress or a research notebook will find the format fighting them, and the fix is a different application, not a setting.

The second is the sync model. Everything is local, and the only sync path is a WebDAV server the user provides. A person with two devices and no server of their own has no path between them, and a person with a server has to run it, secure it and back it up, which is a different skill from taking notes. The privacy guarantee and the lack of a built-in sync are the same decision.

The third is the single maintainer. The README says the power of one person is limited, the AI translations may contain errors, and the project is always in use by its author, which is the strongest possible motivation and also the reason the roadmap is unstated. There is no list of planned features to plan against, and the version history is the only signal of direction.

The alternative approach, for the same person with the same notes, is a self-hosted note service where the server is the product and the sync is someone else's problem. The difference in approach is that IdeaMemo keeps the application small by refusing to be a service, and a self-hosted service keeps the data portable by refusing to be an application, and a user who wants both has to run the WebDAV server themselves or accept a vendor.

There is a third option worth naming for anyone who writes in a language the AI translation got wrong: the source is on GitHub under GPL-3.0, so fixing a string is a patch rather than a feature request, and the contribution guidance in the README, which asks for issues for ideas and for detailed bug reports, is a reasonable path to doing that.

## Conclusion

IdeaMemo fits a person who captures short thoughts in the moment and wants them on their own device, without a company account, without a subscription and without a server, and who is willing to set up a WebDAV space if they want the notes to travel between devices. It is the wrong tool for long-form writing, because the card format is explicitly not recommended for long text, and it is a poor fit for a team, because the sync model is a file store rather than a collaborative database. Before installing it, read the privacy section against your own threat model, since the app asks for no permissions and stores everything locally unless you turn on the WebDAV upload, and check the translation quality for your language, because the README says the localisation was done by AI and may contain errors.

## FAQ

### What is IdeaMemo?

It is a lightweight Android note-taking application written with Jetpack Compose, published on Google Play and through GitHub releases. It is a quick record app built around card-shaped notes with text and images, indexed by hashtag, and it is licensed under GPL version 3.0.

### Does IdeaMemo need any Android permissions?

No. The README states the privacy-first position as needing no permission to be applied, with all runtime data stored in the local database or uploaded to your own WebDAV private cloud. That is what allows the application to keep everything in its own sandbox without a system dialog.

### How does IdeaMemo organise notes?

By hashtag indexing, with `#TAG` used to categorise a note, and the app supports mixed text and graphics. The README notes that as a card note it is not recommended to record long text, so the format suits short captures rather than long documents.

### How do I review old notes in IdeaMemo?

The app supports a calendar view, a heatmap and a random walk for reviewing notes, which gives three ways to resurface what you wrote: by date, by how much you wrote over time, and at random.

## Sources

- [ldlywt/IdeaMemo on GitHub](https://github.com/ldlywt/IdeaMemo)
- [License: GPL-3.0](https://github.com/ldlywt/IdeaMemo/blob/master/LICENSE)
- [Project website](https://play.google.com/store/apps/details?id=com.ldlywt.note)
- [README](https://github.com/ldlywt/IdeaMemo/blob/master/README.md)
- [Releases](https://github.com/ldlywt/IdeaMemo/releases)

---

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