ATOMIC NOTES
Notes that are actually yours.
A local-first notes app with optional, per-note cloud sync. No trackers, no ads, no AI. Your notes are never someone's training data. It was born from a real account breach, then rebuilt to keep it that way by design.
It started with a
breach.
The developer used a mainstream notes app the way most people do. Ideas, mostly. Also a few account passwords and private notes he never should have typed there.
Then one ordinary day the emails started. "New sign-in from a location you don't usually use." One account, then another. What followed was a frantic afternoon of password resets, token revocations, and locked-out services.
Stop using apps that take your data hostage and use it for their own profit.
So Atomic Notes became the app he wished he'd had. He shelved it three years ago, waiting on the tech to catch up. It has. Now it's revived: a new design system, a re-architected sync engine, and a privacy-first foundation.
Your notes became
training data.
The industry quietly changed the deal. "Free" now tends to mean your content is the product. It gets read, profiled, and more and more often fed into models as training data. Your notes are the most personal text you'll ever write. That's not a corpus you should have to donate.
- ✕Your words. Content used to "improve services" and train AI models.
- ✕Your behavior. Analytics and crash SDKs profiling how, when, and what you write.
- ✕Your context. Ad SDKs reading signals to target you.
- ✕Your location of record. Cloud-first by default, so their servers hold the master copy.
- ✓Nothing to train on. The app has no AI, so your notes are never used for training.
- ✓Zero telemetry. No analytics, no crash reporters, no third-party trackers shipped.
- ✓No ad SDKs in the app today.
- ✓Local-first. Your device holds the source copy, and the cloud stays opt-in and per-note.
This isn't a posture bolted on afterward. It's why the app is local-first, why there's no AI, and why the funding model sells convenience, never your content.
Ink on paper.
One signal.
Real screens from the app. Tap any shot to enlarge.
Proof, not
promises.
The parts that matter, straight from the source. One repository as the single source of truth. A sync engine that never clobbers your unsynced edits. And limits enforced where they actually count.
Instant save
Every keystroke settles into on-device Hive storage. Launch never waits on the network, on full 5G or in airplane mode.
Per-note, merged
One row per note, realtime stream, tombstones for deletes, last-write-wins on a server-set timestamp.
Server-authoritative
Row-Level Security + Postgres triggers. Quotas and timestamps can't be spoofed by a client.
// lib/main.dart : startup can time out, but it can never silently die. await Supabase.initialize(url: cred.PROJECT_URL, publishableKey: cred.API_KEY) .timeout(const Duration(seconds: 15)); await Hive.initFlutter(); await NotesRepository.instance.init(); // loads the local copy first // on failure: runApp(StartupFailedApp(error)). never exit(0)
// lib/database/notes_repository.dart : merge without clobbering unsynced work if (local.dirty && local.updatedAt.isAfter(remote.updatedAt)) continue; if (remote.updatedAt.isAfter(local.updatedAt)) { _notes[remote.id] = remote; // remote is newer → take it unawaited(_box.put(remote.id, remote.toMap())); }
-- supabase/migrations/002_per_note_realtime.sql -- updated_at is server-authoritative: a bad client clock cannot win a conflict. create trigger note_touch_updated_at before insert or update on public.note for each row execute function public.touch_updated_at();
-- supabase/migrations/003_note_limit.sql -- The 50-note tier is a UI hint AND a database rule. curl can't add note #51. if live >= allowance then raise exception 'note_limit_reached' using errcode = 'check_violation'; end if;
Sealed on your device,
before it ever leaves.
The next release closes the one real gap. Note content gets encrypted on-device with AES-256-GCM, under a key derived from your credentials, so the server only ever stores ciphertext. Here's the design being built:
// DESIGN: client-side encryption shipping in the next release. // Notes are sealed on-device. Only ciphertext + nonce are ever synced. import 'package:cryptography/cryptography.dart'; final algorithm = AesGcm.with256bits(); Future<SecretBox> sealNote(String plaintext, SecretKey key) => algorithm.encrypt(utf8.encode(plaintext), secretKey: key); // key = Argon2id( passphrase, per-user salt ). Derived locally, never uploaded. // server row stores only: { nonce, ciphertext, mac }. Unreadable server-side.
Try the concept, live
This runs entirely in your browser through the Web Crypto API, with a throwaway AES-256-GCM key. Type on the left. What the server would see shows up on the right. Your text never leaves this page.
Exactly where it
stands today.
An app built in reaction to a data breach doesn't get to overclaim security. So, precisely:
- In transit All backend traffic is over HTTPS / TLS.
- Access control Supabase Row-Level Security. Every policy is
auth.uid() = user_id, so only your account touches your rows. - No tracking Zero telemetry: no analytics, no crash reporters, no ad SDKs, no third-party trackers.
- No AI Nothing sends your notes to a model. No content is used for training.
- Device lock Optional biometric unlock gates the app locally.
- End-to-end encryption Note content sits as ordinary text in your row. Transport and access control protect it, but the operator could still read it. In active development for the next release.
- Local at-rest On-device storage isn't encrypted at rest today.
- Why say so Encoding and access control aren't cryptography, and this page won't pretend otherwise. Being exact now is the whole point.
Restraint as a
feature.
Condensed uppercase headings, hairline rules instead of shadows, and one accent color. The only "shadow" in the whole app is a solid 2px zero-blur offset that mimics offset print.
Where it's going.
Nothing below is finished. This is intended direction, not current behavior.
Client-side encryption
On-device AES-256-GCM under a credential-derived key. The prerequisite for opening the source.
Publish the source
Open the repository to public read access once encryption and hardening are integrated.
Distribution & developer verification
GitHub Releases first. An Amazon Appstore listing, strictly to satisfy AdMob's recognized-store requirement. Android Developer Verification, registered early.
The Atomic Coin system
A gamified, opt-in rewarded-ad economy to fund cloud infrastructure without subscriptions.
The guarantee: a free periodic background sync stays free for everyone. Coins only ever buy speed. They never buy the guarantee that a note is saved, and never buy access to your data. Ad completions get verified server-side (SSV).
Task & reminder notifications
Local notifications for checklists and reminders once the core is stable.
Sideload it.
Keep control.
GitHub-first distribution. No Play Store gate, no account harvesting.