Why I Built Purple — And Why It Took 20 Years to Get Here

I've been thinking about AI since before it was cool to think about AI.

Not the hype cycle. Not the chatbot wave. I mean actually thinking about it — studying it at the University of Silesia in Katowice, where we were taught neural networks, formal logic, and operating system internals in one continuous thread, as if the faculty understood — even in 2007 — that these things would one day converge.

They were right. I just didn't know how long the wait would be.

The Long Road

My first commercial software I did was around 2001 - couple of online store migrations from one system to another, multiple social media apps integrated with Facebook, and my first fully commercial product to support small-mid size hotels - written from the scratch and widely used in Poland.

In 2007 I was writing mobile weather apps. Those apps generated real revenue in Chinese app markets and tought me to respects the user.

That lesson sat quietly in the back of my head through every role that followed — EPAM, contracting at StubHub, Uber, Epic, Pearson. I kept building. I kept shipping. But I also kept watching the AI space with what I'd call a cold fascination. Not a fan. Not a skeptic. An engineer trying to separate the signal from the noise.

The noise got very loud around 2022.

Before "AI" Was Rebranded

While everyone was discovering ChatGPT, I was already doing this:

Building AChat → ASK — a personal AI assistant pipeline before local models were viable
Training a 1.3B parameter Polish language model from scratch — a custom GPT-style transformer, 28 layers, 1536 embedding dimensions, DeepSpeed ZeRO-2, ~51 epochs on an GPU at home, ~2.345 loss. I build couple models in my life but that was first using newer stack and done for personal use and learning.
Writing a Go-based TUI monitoring tool (AIP) just to observe the training process in real time
Exploring PyTorch-to-Go portability and building a Go inference server over llama.cpp via CGO

This wasn't ML-as-marketing. This was me, a single GPU, and a lot of late nights trying to understand what was actually happening inside these models.

The distinction matters. There's a difference between using AI and understanding it. I wanted to understand it.

Why Go

Go wasn't a trendy choice for AI tooling. Python owns that space. But I've been writing Go seriously since my time at EPAM. I actually learned that during development of weather forecasting services for AWS infrastructure - it worked magic with AWS Lambdas and top hype back then was "serverless". And I kept choosing Go — in weather forecasting, multimedia streaming, serverless at MeteoGroup AG GRUB pipelines, for microservices at Epic, for backend systems at Pearson's, for my own tools at home.

Go has a quality I value above almost everything else in software: it does what it says and says what it does. No magic. No hidden allocations you didn't ask for. I hated Java because of being quite opposite. Go is not a Java and fancy framework that quietly owns your architecture.

For an application like Purple — where the entire agentic loop, SSE streaming, tool dispatch, plugin orchestration, and SQLite persistence all need to run correctly, reliably, on whatever Linux kernel the user has — Go is not just a preference. It's the right answer.

I also built AwesomeGoBuilder aka Autobuild-Go — a parallel builder for Go-based microservices — back in 2019-2021. It ran fmt, lint, mock generation, module downloads, tests, benchmarks, race condition detection, and the final build in a single coherent pipeline. 0.84 seconds end-to-end on a real project. That kind of discipline — from format checks to race detector — is the same discipline baked into Purple's architecture today.

What Purple Actually Is

Purple is a local-first agentic AI assistant for Linux and macOS. It:

Connects to your local Ollama instance — no API key, no cloud, no telemetry
Executes shell commands with a 5-tier approval system (read-only runs silently; destructive always asks)
Integrates with Gmail, Calendar, Drive, and Dropbox via OAuth2
Runs 20+ tools, all gated by configurable approval tiers
Stores everything — conversation history, OAuth tokens, memories — in a local SQLite database at ~/.purple/purple.db
Supports Lua extensions: drop a sandboxed script into ~/.purple/lua, and it becomes a tool the model can call
Has a Kids Friendly Mode with age-adapted responses, hard-blocked sudo/write operations, and safe-source web filtering
Ships as AppImage, RPM, TGZ, and a universal macOS DMG

The stack: Go 1.23 for all of the backend. WebKitGTK 4.1 on Linux, WKWebView (Cocoa) on macOS — the entire UI runs in an embedded WebKit view. GTK3 / Cocoa for native windowing. Bazel for reproducible, hermetic builds that produce RPM, TGZ, and AppImage from a single command. Vanilla JS, no Node, no npm. SQLite. URW Gothic embedded as woff2.

No framework owns my architecture. I own my architecture.

The Thing I Actually Care About

I built Purple because I believe powerful AI assistance should not require a credit card or a cloud account.

That's not idealism. That's a technical position. Local models are good enough now. The hardware is accessible. The only thing standing between a developer and a capable private AI assistant is someone willing to wire it together correctly.

I was willing to wire it together.

Purple is still a personal project. A few months of evenings and weekends. I build it for my own workflow, fix things when I hit them, add features when I need them. But it's now in beta6, it runs on both Linux and macOS, it has a real agentic task mode with plan review, loop detection, reboot resume, and parallel tool execution — and I use it every day.

That's the bar I hold my own software to: does it solve a real problem for me? If yes, it might solve one for you too.

What This Trajectory Looks Like

Purple didn't come out of nowhere. It came out of:

First web server (HTTP) based on TSocket written in Delphi for Windows 98 in early 1999.
A CS curriculum in Katowice that started with MIPS assembler and OpenGL, first steps in Machine Learning at the Math, Physics and Chemistry faculty. before it ever touched networking
17+ years of engineering across many companies and notably those most impacting me: EPAM, StubHub, Uber, Epic Games, Magic Leap
A long, patient conviction that ML — before it was rebranded AI — was going to matter
And a stubborn preference for local software, local data, and tools that work when the internet doesn't (I developed plenty of Cloud and Mobile in my life)

If you want to see what I mean by local-first AI with real tool execution: getpurple.net

Roger out,

~Matt