AI Journal
A journal that thinks — and keeps it to itself.
A private iPad journal with a language model that runs entirely on the device, through Apple’s MLX. It reads what you write, reflects it back, and never sends a word anywhere.
01The idea
The most private thing you write shouldn’t be the first thing you upload.
Your entry makes a round trip.
To get a summary or a mood, the words leave the device, get processed on a server you don’t control, and come back.
The model comes to the words.
A compact language model runs on the iPad’s own chip. Reflection, summaries and mood all happen locally — with the Wi-Fi off, if you like.
02Try it
Write something. Watch it think.
Type a few lines — or pick one — and press Reflect. Then flip the network off and do it again. Nothing about the result changes.
Your reflection will appear here — generated where you are, not on a server.
Honest footnote: this web demo uses a tiny word-list model running in your browser, just to show the flow. The app does the real thing — a language model running on the iPad through Apple’s MLX.
03Over time
A week, read back to you.
Each entry gets a quiet sentiment read, so patterns surface on their own — the good days, the heavy ones, and what they had in common. The same local model writes the summary.
Mood this week · example data
04What it does
Four things, all of them local.
Privacy first
All AI processing happens on the device. No account, no upload, nothing sent to the cloud.
A local language model
Powered by Apple’s MLX framework, built for efficient machine learning on Apple silicon.
Smart insights
Summaries and gentle reflections generated from your own entries, not from a template.
Mood tracking
The sentiment of what you write, tracked over time, so the pattern shows up before you name it.
05How it works
Inference, in your hands.
MLX runs the model in the iPad’s unified memory, so the same chip that draws the interface also does the thinking — no round trip, no waiting on a connection.
import MLXLLM
import MLXLMCommon
/// Turns one entry into a short reflection — on-device.
@Observable final class Reflector {
private var model: ModelContainer?
func prepare() async throws {
model = try await LLMModelFactory.shared
.loadContainer(configuration: .journal)
}
func reflect(on entry: String) async throws -> String {
guard let model else { return "" }
return try await model.perform { context in
let input = try await context.processor
.prepare(input: .init(prompt: .reflection(entry)))
return try generate(input: input,
parameters: .init(temperature: 0.4),
context: context) { _ in .more }
.output
}
}
}The snippet is illustrative: it shows the shape of the on-device path, not the app’s source.
06My role
What I built.
An exploration of what AI feels like when it never leaves the room. I’ve since shelved it: the idea carried on as A place to rant, a journal in the browser that works with whichever AI you already use.
- 01
Privacy as the product
Designed the app around one rule — the words never leave the device — and let every feature follow from it.
- 02
On-device intelligence
Built the offline AI layer with Apple MLX to run language-model features locally: reflections, summaries and sentiment.
- 03
A calm iPad interface
Designing a SwiftUI writing surface where the AI stays quiet until it’s asked — a journal first, a model second.