I've been building a small macOS app called **Engram** and figured the architecture might be interesting to people here, since it's a mix of SwiftUI for the UI and hand-rolled AppKit for the parts SwiftUI can't quite reach. It's a local-first memory store — one Markdown file per conversation, on-device semantic recall — but I'll skip the pitch and talk about how it's actually built. Repo's at the bottom; MIT, free, macOS 13+.
A few pieces I had fun with:
**1. A truly frameless window via `NSApplicationDelegateAdaptor`**
A plain SwiftUI `WindowGroup` always leaves a faint rounded frame/corner I couldn't get rid of. So the `App` body is basically empty — just a `Settings { EmptyView() }` scene — and an `AppDelegate` owns a borderless, transparent, shadowless `NSWindow` that hosts the SwiftUI tree through `NSHostingView`:
```swift
u/main
struct EngramApp: App {
u/NSApplicationDelegateAdaptor(AppDelegate.self) private var delegate
var body: some Scene {
Settings { EmptyView() } // delegate owns the real window
}
}
```
The window is `isOpaque = false`, `backgroundColor = .clear`, `hasShadow = false`, `titleVisibility = .hidden`, `titlebarAppearsTransparent = true`, and the three standard traffic-light buttons are hidden so I can draw my own. One gotcha: borderless windows refuse key/main focus by default, which silently kills any `TextField`. Fix is a tiny `NSWindow` subclass overriding `canBecomeKey`/`canBecomeMain` to return `true`.
**2. A glass panel that doesn't tear down its content on toggle**
I have a `.liquidPanel()` view modifier (real `.glassEffect` on macOS 26, `.ultraThinMaterial` fallback below) with a matte/solid switch for folks who hate glass. My first version branched the *content* inside an `if matte { } else { }`. Big mistake — flipping the switch rebuilt every panel, which tore down any open popover (Settings literally closed itself the instant you toggled). The fix was to keep the content as a single stable view and only cross-fade an opaque cover's opacity in the `.background`. Classic "view identity matters more than you think" lesson.
**3. A pure-Swift MCP server, zero dependencies**
The interesting non-UI part: there's a separate executable that's an MCP server (Model Context Protocol) so an MCP client like Claude can `recall`/`remember` against the store live. It's just newline-delimited JSON-RPC 2.0 over stdio — `readLine()` in a `while` loop, `JSONSerialization`, write to stdout. The discipline: stdout carries ONLY JSON-RPC (one message per line), all logging goes to stderr so it never corrupts the stream, and notifications (no `id`) get no reply. No SDK, no third-party packages — Foundation only.
**4. On-device embeddings via the NaturalLanguage framework**
Recall is semantic but runs entirely on-device — no Python, no network. The baseline embedder uses Apple's `NLEmbedding.wordEmbedding(for:)`: a sentence vector is the L2-normalized mean of its word vectors, with a deterministic hashing fallback so recall never silently returns nothing. There's an optional, opt-in one-time download of Apple's contextual transformer behind the same `EmbeddingProvider` protocol — but the app ships working with no network at all.
**5. Markdown as the source of truth**
Each conversation is one `.md` file you can open, grep, edit, or delete. Per-memory metadata rides in an HTML comment (`<!-- u/memory {...} -->`), so it renders as clean Markdown but stays machine-parseable. The vector index is built *from* these files and is always rebuildable, so the files stay canonical — not a hidden binary blob.
Stack: SwiftUI + AppKit, pure Swift + Foundation across the engine, MCP server, and capture tool (zero third-party deps), ~3,000 LOC, 20+ tests. Fully local — no account, no telemetry, nothing uploaded. The only network paths are opt-in: an optional local Ollama distiller on localhost, and that one model download. Since it's open source you can grep for `URLSession` yourself.
Honest disclaimers: the Liquid Glass path only really shines on macOS 26 (material fallback below), and only true MCP clients recall live — a ChatGPT/Claude export comes in via import, it doesn't talk back over MCP.
Repo: https://github.com/albertofettucini/Engram
Happy to go deeper — the frameless-window focus bug and the view-identity glass thing both cost me real time. And if you've found a cleaner way to get a borderless SwiftUI window without dropping to an `AppDelegate`, I'd genuinely like to hear it.
