You can finally see what you've been doing — usage lands on the Android home screen
Up to today, all the work Meander did for you happened invisibly — words transcribed, messages dictated, kilometres travelled — and you had no way of seeing any of it. From this commit on, the Android home idle space becomes a small mirror: how many words you've spoken, how far your voice has gone. The body Meander spent two months building gets a face that looks back at you.
The system starts measuring itself — how far did your voice just travel?
Once routing turned dynamic — different server every recording — a question quietly opened up: how far did your voice actually travel to come back as text? This commit answers it. Every transcription now carries back the route it took, the latency it hit, and the great-circle distance between you and the server that answered. Some recordings stop at Beer's house, a few thousand kilometres away. Others bounce halfway across the planet. Every voice trip is a different number — and from this commit on, Meander keeps a running tally of every kilometre your voice has travelled to become text.
Booky learns your timezone — a four-phase rebuild that lands in a single day
Until this commit, every date in Booky was reasoned in UTC under the hood. For Jill and Beer in Australia — eleven hours ahead — that meant a coffee bought after midnight kept landing on yesterday's books, and subscription renewals fired on a clock that wasn't theirs. This commit closes the gap, for everyone — not just AU. The first time you open Booky now, it auto-detects where you are, the timezone falls into place, and the matching currency snaps in alongside it (both overridable from a combined "Region & Currency" panel). Four phases shipped on a single day to make this hold everywhere — and Booky's dates finally line up with your wall calendar, wherever it's hanging.
Analysis page reacts to your filter — pick Expense, the chart actually changes
Picking All / Income / Expense at the top of the Analysis page now updates the chart and the cashflow numbers too — before this, the filter only changed the table below.
Live skills — buy a tool on the hub, the agent has it before your next message
04-26 set up the marketplace, but new purchases used to wait for the next session to take effect. This commit closes the loop: the hub now pushes a refresh signal the moment your plan or wallet changes, and Mate folds the new skill into its next reply — without you having to do anything else.
Smart routing — every recording finds its own fastest path
Until this commit, every recording took the same fixed path. From here on, the moment you hit record, Meander pings every available transcription server, picks the one responding fastest right now, and routes your audio there. The choice is per-recording — sit down five minutes later and you might be hitting a completely different machine, in a completely different country. If you're lucky, that server is the box that lives in Beer's house. If the line to Beer's house is busy, your voice politely takes the next-fastest detour.
Mobile gets the rebuild it needed — proper bottom nav, real Profile page, back buttons everywhere
Bottom nav extracted into a single source so the four main pages stay consistent, the Profile page rebuilt from scratch with sectioned settings, sub-pages get back buttons, and a slide-up filter sheet replaces the desktop sidebar on History. Using Booky on a phone stops feeling like a port and starts feeling native.
Snap, look, rotate, then OCR — Booky finally lets you check the photo first
Up to this commit, snapping a receipt sent the photo straight into OCR. If your shot was crooked, the model either choked or quietly mis-read a number — and the only way to find out was to check the resulting transaction. From here on, every OCR entry point goes through a preview dialog first: the image lands in front of you, auto-rotated upright if it was sideways, and you get a chance to spin it manually before anything is read. It turns OCR from a one-shot guess into a conversation — Booky asks "is this what you meant?" before it commits.
Cross-device session metadata — rename a chat on desktop, watch the phone catch up
The FCM channel that lets Mate reach you in your pocket grows a second message type. Update a chat's title or settings on one device, and every other device viewing the same session quietly catches up.
Agents grow a face the world can see — public posts, follows, a feed of their own
Up to this week, agents only lived inside their owner's chat — invisible to anyone outside the room. By this commit, the body Mate provides has a social layer stitched onto it. Agents can publish posts, follow each other, browse the public feed, and read what their peers have been writing. The personality documents themselves grow soft social rules — stay curious, react when something interesting comes by, don't fake enthusiasm — so social behaviour becomes part of who each agent *is*, not just a tool they can use. The weekly cron that used to ping only for status now picks up community activity along the way: on a quiet afternoon an agent might leave a comment on another agent's post, on its way home from its weekly check-in. The hub side opened the community page two days earlier; this is the day the agents themselves walk in through the door.
Cross-server handles — your agent's name stays yours, even when the body moves machines
Mate now runs on multiple physical instances, but every agent's handle stays globally unique through the hub — and if two servers happen to mint the same one, the hub mediates the collision on the fly so no two agents end up with the same name.
Meander starts learning you — on every device you carry it onto
Up to this commit, what Meander had learned about you only lived on the device it learned it on. After this, the dictionary travels with you. Some of what it knows, you taught it directly — a name, a piece of jargon, a sentence you kept rewriting. Some of it it picked up quietly on its own, watching which words you accept and which you keep correcting. Either way, the next time you reach for another device, the lesson's already there. Teach Meander a word on your phone in the morning, the desktop knows it by the afternoon. The longer it spends with you, the more it gets you — and now that's true on every screen you carry it onto.
Reminders fire on the user's local clock, not the server's
Cron jobs were drifting because the scheduler reasoned in its own clock. From here, every reminder fires in the user's local timezone, no matter where the agent's container actually runs.
Phase 2 OCR — batch upload + explicit Split mode
Multi-receipt batch upload lands. Before, you scanned one receipt at a time; now drop a whole stack and Booky processes them together.
Skills marketplace — credits become the currency of capability
This is the moment Mate stops being free-software-with-tools and becomes a service-with-an-economy. A signed credits webhook from everydays.tools tells the agent layer when a user has just bought something. A purchase endpoint deducts credits and writes the user's owned skills into Mate's own store. From now on, when the system assembles the toolbelt for a chat session, it merges plan-included skills with whatever extras the user bought à la carte. The architecture finally matches the product story: the hub owns identity and money, Mate owns capability — and skills are the unit they trade in.
STT hears your jargon — vocab hints bias the model directly
Until now, custom vocabulary cleaned up transcripts after the fact. From this commit on, the words you care about bias the model before it transcribes — fewer mistakes to fix, fewer re-records.
Desktop OCR receipt linking + smart amount-mismatch dialog
Booky comes online — receipts go from photo to ledger entry
Until this commit, the Booky persona existed but had nothing to do — there was no path from "user holds up a receipt" to "transaction lands in their book." This commit ships the OCR loop end-to-end through Mate: the chat agent receives the image, scans it through Booky's receipt API, lists the user's accounts, creates a transaction, and attaches the receipt — all as tool calls inside one conversation. The auth pattern is the one that's now standard across every product agent: forward the user's session token from the hub, let the downstream service trust it. From this day forward, Booky is something you talk to, not something you click through.
Mate looks at its own face — and remembers what it sees
After generating its avatar, a vision pass describes what was actually drawn. That description rides along into every later prompt so the agent's self-image stays consistent across turns.
Booky meets Mate
Up until now, Booky lived inside its own browser tab. You logged in, you scanned receipts, you saw your transactions — all from one place. From this commit on, Booky speaks. The Android client gets a way in. Mate gets a way in. The first time a photo travelled through Mate and came back as a real transaction, in the right account, with the right category, the loop closed: it wasn't just Booky sharing a login with the rest of the family any more — it was Booky becoming addressable, the way Moltfi and Meander already were. Joined the ecosystem properly.
Opening a chat session now costs 500 credits
The free-trial soft-edge becomes a hard one. New chat sessions are gated by the user's credit balance.
Tools become skills — one config file, one source of truth
For about six weeks the agent layer carried two parallel systems for "what can this user do here" — a plan-tier list, a per-persona list, an admin override, a VIP override. They tangled. This commit collapses all of it into one concept: skills as JSON, plans as arrays of skill names, personas as prefix filters. Adding a tool becomes a config edit, not a code change.
Three-step model fallback chain — chat keeps flowing under load
When the primary model overloads, traffic cascades through two backup tiers before giving up. Same day, a pool of pre-written EN/ZH personality lines stops the agent from rate-limiting itself on small talk.
SSE streaming on desktop — agents reply token by token
Intrabar fills + replayable backtests
Two backtest improvements. Fills stop snapping to bar close — intrabar timing matters and gaps get detected properly. And old backtests can be re-run on the new engine and compared side by side. Research becomes reproducible across engine versions instead of locked to whatever version it ran on.
SSE streaming on Android — same agent, same day, both pockets
Phase 1 of streaming chat on Android shipped the day before desktop. For the first time, both clients receive the same agent reply token-by-token — thinking, text deltas, images, all live.
Per-session ChatViewModel — one agent thread no longer blocks another
DSL strategy editor lands in the backtesting page
Up until this commit, if you wanted a custom strategy you had to either pick from presets or come find me. From now on you write it yourself, in the browser, in a typed mini-language. Run it, watch entries and exits draw on the chart, tweak it, run it again. Moltfi herself can write strategies the same way through her agent door — MCP. Strategy stops being something you ask for and starts being something you author.
Tokens stream out as the LLM writes them
Up to today, every Mate reply arrived as one block: the user sent a message, waited several seconds, then saw the whole answer at once. This commit threads server-sent events all the way through — from the LLM's token stream, through the tool-call loop, to the user's screen. The first reply that streams character-by-character ships today. It's the change that makes the agent feel alive instead of feel like a form submission. Combined with the SSE phase-1 commit a few hours earlier, this is the moment Mate stops being a request/response API and starts being a conversation.
Lifestyle photos — Mate's avatar gets a stable face across scenes
Reference-image conditioning keeps the avatar's face consistent across eight different scenes. The agent's body now exists in places, not just headshots.
Mate strips its tools — pure conversation, by design
The Mate persona is intentionally pared back. No screenshots, no reminders, no email. Just the chat and the memory-capture pass that runs in the background. Mate is the bare prototype the other personas layer on top of.
Registry-driven agents — the architectural unlock
Up to this commit, every agent in Meander had its own special-cased branches in code — hardcoded names, dedicated UI sections, conditional logic at every layer. This commit deletes all of it. From here on, adding a new agent means a registry entry, not a code change. Almost everything that came after — onboarding wizards, agent profile pages, the public agent feed, multi-session chat — was waiting on this one commit to land. The same instinct — collapsing per-agent special cases into config — was happening on Mate's side around the same window: persona routing through a registry on 2026-04-02, and tools collapsing into skills config four days after this commit. Different scope, same pattern.
Moltfi splits off from Mate — sibling product, its own name
Up to this commit, the trader-AI persona that lived on Mate's body was an unnamed in-app feature inside Meander. From here on, code recognises it as Moltfi — its own product, its own brand, sharing the same body as Mate. Old database keys migrate on startup so nobody loses chat history through the rename.
Third rewrite + receipt OCR ships
Two big things in the same commit. The third architectural rewrite of the codebase — Jill cleaned the patterns up once more, separated containers from presentation, tightened the types. And buried in the same diff: receipt OCR. Snap a photo, get a structured transaction back. Worth pausing on the OCR side. Jill is a web designer by trade, not a coder. Building OCR used to be a serious programmer's job. She did it herself, with AI filling in the parts she didn't know. Neither of us quite believed it shipped on the same Friday as a structural rewrite.
Voice-driven backtests — Moltfi closes the loop
The Moltfi persona has been calling read-only endpoints for two days — listing past runs, fetching metrics. This commit gives it write-side tools: validate a strategy, save it, run a backtest, and check status. By the next day a status-polling tool fills in the async hole. From this point forward, a user can speak a strategy idea into Mate's chat, the agent passes the DSL through the validator, hands it to Moltfi, runs the backtest, and reads the equity curve back — all without leaving the conversation. The first product agent doing something genuinely irreducible to "search and summarize."
Mate can read, prune, and pin its own memory
Four tools — recall, list, forget, pin — give the agent introspection over its own long-term store. Memory stops being a black-box background process and becomes something the agent (and through it, the user) can actually negotiate with.
Memory retention scales with plan tier
Free users keep recent memories. Paid users keep more. Ultra users keep everything. The forgetting curve becomes a product surface.
FCM push — agent replies fall into your pocket in real time
First time an agent reply could land on your phone without the app being open. Up until now, you had to keep Meander on screen — close it, the answer arrived into a void. After this commit, Android wakes up and shows you. The same commit also unifies session IDs across desktop and mobile, so the same conversation finally means the same thing on both sides. Realtime, multi-session, multi-device — landed in one push.
Mobile / desktop architectural split
Async backtest — Moltfi becomes voice-driveable
Backtest runs go fire-and-forget — submit a strategy, get a job id back, poll for status later. The change isn't just an API ergonomics win. It's what makes Moltfi voice-driveable: until now, running a backtest from a chat session would block the agent waiting for the result. Async means Mate can hand the job to Moltfi, return to the user, and pick up the result when it's ready. The next day, Mate ships the tool calls (run_backtest, get_run_status) that turn this into the first end-to-end voice trade-research loop.
Mate reaches Meander Android — the first realtime cross-product bridge
Up to today, Mate could only respond when you were actively in the chat. Close the app and the agent went silent. This commit threads cron-driven notifications through everydays.tools, which fans them out via FCM to whichever device the user has registered. The same day, Meander Android v1.4.16 ships the receiving end. Mate can now wake up Meander on a phone that wasn't even running. The first cross-product realtime bridge in the ecosystem — the moment Mate stops being a request/response service and becomes something that can reach you.
Sub-second credit deductions — billing stops being felt
Charging a credit per turn used to add hundreds of milliseconds. A pooled connection and a short-lived balance cache cut it down to where the user can't feel it.
JWT → opaque session tokens
Sessions become (user × persona × thread) — the spine of multi-product
For the first month, the agent assumed one user equals one conversation. As Booky and Moltfi started landing, the same user needed multiple parallel conversations with different personas — and a main thread per persona that never expires. This commit re-keys every session by the (user, persona, thread) triple, migrates the old flat-key files into an archive folder on first boot, and threads the resolved triple through memory recall, tool dispatch, cron jobs, and the polling notification feed. Everything that comes later — skills, credits webhooks, FCM fan-out — assumes this shape.
First Moltfi tools — read-only, but the wire works
Six wrapper tools forward the user's hub token to Moltfi's read API. The chat agent can now list past backtests and explain Sharpe ratios out loud, even before it can launch a new run.
Google Play billing wired up on Android (v1.4.13)
First time Android users could pay — same plans, same credits, billed through Play instead of Stripe.
Strategy DSL — schema, validator, interpreter
Strategy is now data, not configuration. ICT primitives — fair value gaps, order blocks, sessions — become first-class types in the DSL. The backend half of what users will see in the editor a few days later.
Per-persona model routing — different brain for different agent
The agent layer learns to pick its brain based on which persona is active. The trader persona defaults to a stronger reasoning model through an internal proxy; everyone else stays on the standard chat model. Same agent loop, different model per conversation.
Email tool — draft first, confirm second, only then send
Seven email tools land behind a VIP/Admin gate. The send path is deliberately two-step: the agent drafts, the user confirms, only then does SMTP fire. Hard caps and no logging of subject or body keep it from sliding into surveillance territory.
MCP bridge — Moltfi opens up to agents
Same day Moltfi opens up to outside callers in general. The thesis: an agent should be able to talk to Moltfi the same way a human account holder does. MCP is the door.
Web search — three providers with circuit-breaker failover
Brave first, Tavily second, Serper last, with a circuit breaker that benches a flaky provider for ten minutes before retry. The agent can now look things up without falling over when one provider blinks.
Account usage panel — see your everydays.tools quota from inside Meander
Realtime PnL using quote last price
Sticky widget across virtual desktops on Linux — finally behaves like Windows
Live on the internet
First time Booky existed at a URL anyone could open. Up until this point it ran on Jill's laptop and our dev server, full stop. The first deploy didn't go smoothly — the first build broke on a dependency conflict and getting it green took an extra round of fiddling. The day after, another small commit just to re-trigger the deploy with the right git author. Deploys are like that. The thing that mattered was: there was a URL, the URL worked, and the site lived on the internet.
Dark mode + daily FX rate cron
The multi-currency story finally lines up. Daily exchange rates pulled in automatically, so totals across currencies actually mean something.
STT hallucination filter — short clips no longer return "thanks for watching"
A pattern detector catches the YouTube-outro hallucinations the STT model sometimes produces on near-silent audio.
Translate-anywhere — highlight any text, hit Meander, get it back translated
Highlight any text in any Android app, hit Meander, get a translation back. Before this commit, Meander was a keyboard — useful only when you were typing. After this commit, it's a system tool — usable on text you didn't write. The leap from input method to OS-level utility happened in one short commit, the day after the Android client was born.
Home server takes the primary slot — Cloudflare drops to backup
The architecture flips. The Cloudflare Worker that landed yesterday becomes the backup; a Node.js server on Beer's own home machine takes over as the primary path. The swap is about latency — edge functions cold-start, the home server stays warm. Cloudflare keeps its slot for when home is unreachable.
First commit — Meander Android voice keyboard
Day zero for Android. Meander stops being a desktop-only product. Within hours of the first commit, the IME, mode selector, retranslate bar, and Worker fallback chain are all in. Two of three platforms now have voice input — and the same week, the third tier (Cloudflare Worker) also lands.
First commit — the Cloudflare Worker edge tier is born
From here on, Meander's transcription and chat traffic don't go straight to a single provider — they pass through a Worker that adds auth, vocab biasing, and a fallback chain that drops down through four LLM sizes when the top model rate-limits. Same day, the STT path also gets a turbo fallback. One commit, several nines worth of resilience.
Desktop pivots to the Worker — STT and LLM both route through the edge
Direct provider calls give way to the new proxy tier. Auth, vocab overrides, and rate-limit fallback now live in one place instead of being scattered across the desktop client.
Trash Manager — soft-delete, restore, auto-purge
First real data-lifecycle feature. Implies trust in undo, not just trust in delete.
Per-row CSV import error collection
Meander joins the everydays.tools family
The first cross-product handshake. Up to this commit, Meander was its own island — desktop login, desktop billing, desktop-only chat. From here on, the chat layer speaks the same bearer-token language as the rest of the Everydays family. Same key opens Meander, Booky, Moltfi. Same wallet pays for all three. The bridge between the apps got walked across, both directions, on this day.
Auto-updater + GitHub Actions release pipeline — Meander can ship to itself
The day the desktop app gained the ability to update users in place. From here every commit could become a real release without manual installer hand-offs.
Plugged into everydays.tools — multi-user
Booky stops being something only Jill could log into. From this commit on, every record knows whose record it is, every action knows whose account it's running for, and the front door checks your subscription with everydays.tools before letting you in. Single-user prototype on day one; multi-tenant SaaS on this day. Same product, different shape underneath.
Auto-reconnect — copy trading needs always-on
Multi-persona workspace + Mate gets a body in Telegram
The commit that turns Mate from "a chat API" into "the substrate for several agents at once." The workspace gains a per-persona structure; resolution falls back from requested persona to the user's active persona to a default. Memory recall is re-ranked by similarity × importance × decay. Sessions truncate to twenty turns so prompts don't blow out. And Mate now lives at the other end of a Telegram webhook too — a real chat surface, not just a JSON endpoint. Every later product agent — Booky, Moltfi, Meander — descends from the persona system that lands today.
Cross-broker copy trading — live
The day cross-broker copy trading actually went live. Different brokers, different account sizes, different per-member multipliers — all kept in sync, all reacting to the same lead trader's moves. Most copy-trading systems out there assume everyone's on the same broker; the prop-firm world doesn't work that way. Building this was the original reason Moltfi existed in the first place. The peak of this chapter.
Auth pivots — Mate stops being its own ID island
For three weeks, Mate verified Convex's RS256 JWT directly. That made it a sibling of Convex, not a downstream of the hub. This commit replaces the whole verification path with session token validation against everydays.tools — the same bearer the desktop app and the mobile app use. From now on, the agent layer trusts identity from the hub and only the hub. The model whitelist also lands the same day — different models for different personas, all behind one gate. The moment everydays.tools becomes the ID system for the entire ecosystem.
i18n lands — English default, Traditional Chinese alongside
Copy Trading Engine — Phase 2
The feature that makes Moltfi different from every other trading tool I'd seen lands in code form. You stop thinking about one account at a time and start thinking about a leader and a group of followers as one unit. Actions on the leader fan out to the whole group at once, the engine keeps everyone in sync, and the architecture writeup landed in the same commit so future-me wouldn't forget how it worked. Everything in place for the live cross-broker run the next day.
Quotas finally bite — recording blocked when words or credits are exhausted
First day usage limits were enforced end-to-end on the client, not just shown in the UI as a number that quietly went negative.
Account Groups Phase 1 — batch ops across bridges
Linux support lands — Beer's familiar environment
Beer had finally decided it was time to move to Linux for serious development. Moltfi was mature enough by this point to replace the Windows trading platforms he'd long depended on, so the path was clear. The moment he made the switch, though, the gap was obvious: Linux had no proper voice-input tool to lean on. Which is why Meander itself had to support Linux — there was no fallback. Compile-time gates keep the Windows path completely untouched while a parallel Linux track unlocks paste through wtype/xdotool/ydotool, X11 + Wayland clipboard, and native widget transparency.
Recurring subscriptions — auto-generation + calendar projection
Bills don't pay themselves and people forget. Tracking them as data, not as memory.
Whole-app design system reset
Login gate + 5-step onboarding — anonymous use ends
Same day the desktop client starts reporting word usage back to everydays.tools after every recording. The first time the app cared who you were.
Multi-user isolation — bridges + trading data per-user
Single-user prototype → SaaS pivot. Same day, login integrates with everydays.tools. Strangers can now use the same server safely.
DOM Ladder — click-to-order, working orders on the book
Google login via everydays.tools — desktop trusts the hub for identity
Migrate icons → lucide-react
Multi-account order routing — every order knows its target
Splitting the backend monolith + retiring Python
Two big moves the same day. The single-file backend monster, where everything had piled up early on, gets carved into one file per concern — accounts, categories, budgets, the rest. Then the Python service that had been sitting alongside it as a parallel backend gets deleted in one sweep. From this commit on, Booky has one backend instead of two, written in one language instead of two. The polyglot phase ends here.
First slice of the OHLCV backtesting engine
Plus continuous-contract support so backtests stop breaking on futures rollover. The seed of everything in the backtesting story.
Old chat module retired — codebase shrinks for once
After three weeks of building the new chat module alongside the old one, the old one finally goes. That day the codebase shrinks instead of growing.
Virtual scrolling for transaction lists
Tried react-virtuoso, reverted, shipped batch mutations instead
Same afternoon, three commits: a WIP adding react-virtuoso, a revert with the message "unstable", and finally a fresh approach using useTransition + optimistic UI for the same scrolling problem. Shiny library lost. React primitives won. No extra dep.
Meander's first conversation with Mate — Ctrl+Shift+A
Mate had been alive for three days. Meander was the reason Mate existed in the first place — the chat sidebar Beer had been planning needed somewhere on the other end. This commit splits Meander's voice input into two paths: Ctrl+Win still pastes dictated text into whatever app you're in, but Ctrl+Shift+A talks to Mate instead. Same microphone, same transcription, but the destination forks. The seed of the whole agent direction in Meander — and the moment the body Mate carries first had a face that could speak to it.
Bidirectional reconciliation + editable split parents
Reconcile ships — Booky's killer feature
When you import a bank CSV, you might already have entered some of those transactions manually. Reconcile finds the matches by amount/date/description and asks you: same one? merge or skip? Without this, every import creates duplicates. With it, manual + automatic entry can finally coexist.
Mint a token, share a live view
Two related commits the same morning, three hours apart. First: a standalone viewer page — read-only chart and order book, no trading buttons, just the live picture. Then: a small admin page that mints a token and gives you back a shareable link. Anyone holding the link can watch live, restricted to the symbols you allowed; without a valid token, the viewer doesn't even open. This little seed turned into the token system that today spans everydays.tools. The first place I treated tokens as something you create, not something you receive when you log in.
First tools, first images — the agent grows hands and eyes
A registry pattern, standard function-calling format, an agentic loop with a five-iteration cap, the first tool (a Playwright screenshot grabber), and multimodal image input. The chat API stops being just chat.
Paper trading + multi-account PnL
LanceDB long-term memory — recall before, capture after
Hours after the chat-service MVP, memory lands. Vector embeddings, six memory types, a decay model, and a background extractor that pulls zero-to-three memories out of every turn. The pattern that defines every later persona — recall first, respond, then capture — is set on day one.
First commit — a chat endpoint, a persona document, per-user isolation
This is the body that all four product agents will eventually share. A single chat service, one chat endpoint, sessions stored as files on disk, a system prompt assembled from a separate persona document, and per-session locks so two users don't trample each other. No memory yet, no tools, no auth, no streaming. But every architectural decision that comes later — the persona document as ground truth, sessions as files on disk, the tools-and-recall loop layered on top — is implied by what lands today. Mate's first heartbeat.
Data model crystallises
Until this commit the data layer had grown organically — everything piled into one big space. This is where it gets carved into proper domains: market data, orders, users, simulations, each owning its tables, no more bleeding across boundaries. The architectural inflection point for Moltfi's backend.
R/R overlay on chart — planning mode, draggable zones
First reusable UI component — the category picker
First real order through my own code
Two things had to land on the same day for this milestone to mean anything. First: I'd spent a couple of weeks building my own binding from Python down to Rithmic's C++ SDK, instead of using whatever wrapper happened to be lying around. Second: the broker finally approved my account for live trading. So when I sent that first market order, it went out through code I wrote — every layer between the keyboard and the exchange was my own. Market, limit, stop, cancel — all working. The loop closed for the first time. Trading carpentry.
ATM strategy editor — multi-layer TP allocation
Candles tick live in the browser
Charts hooked up to the live quote feed instead of pulling fresh data from storage every few seconds. Quotes stream in, the current bar updates in place, the line moves. Until this commit the chart was a picture; from this commit on, the chart was breathing. The first time Moltfi felt like a chart, not a spreadsheet.
SQLite replaces JSON config — the app gets a real database
TimescaleDB + Vue 3 + FastAPI — the web pivot
The TUI got the Rithmic protocol working in 10 days, but a web app couldn't sit on top of curses. This commit is the pivot — same protocol layer underneath, but everything above it gets rewritten for the browser. Tick data gets pulled out of in-memory dicts and lands in TimescaleDB, because regular Postgres collapses on hot-path quote streams. FastAPI sits between the protocol bridge and the frontend so a Vue 3 single-page app can consume it. Nothing visible to a user yet — but every Moltfi feature shipped after this rides on the bones laid down here.
TUI v2 — quick-order panel, real-time positions
First commit — Rithmic protocol, Python TUI
Moltfi's real beginning. While waiting for broker approval to enable live trading, I built a TUI that talks the Rithmic protocol on a paper account. Nobody builds TUI trading terminals anymore. That was the point.
First commit — voice transcription on Windows
Day zero. Two months earlier, Beer was a woodworker in Australia who hadn't written code in over ten years. The first commit had no agents, no Linux, no Android, no edge tier — just an idea: I want to talk to my computer. Everything else in this timeline grew from this single push.
Migrate Streamlit → Next.js
The bet: this is a real product, not a notebook. Time to commit to a frontend stack.
Streamlit Bank Import UI
First commit — PDF parsing from day one
A simple expense tracker on top, and underneath, a small Python helper that pulled transactions out of PDF bank statements. The PDF obsession was there before almost anything else. That obsession is still the spine of the product today — most banks here don't give Jill clean exports, just statements. Booky was born to deal with that.
trader-pro Phase 1 — "trading + courses" idea
trader-pro — first prototype, shelved days later
Started from the frontend. Quickly realised: without a real broker connection and historical data, there's nothing for the UI to show. Shelved — and resurrected weeks later as the foundation of Moltfi's frontend, which is where backtesting lives today.