I have been working on this as a personal project for a while and it has proved very useful. It is called JoeBro, and it is a native macOS app with a bundled backend: one Python file, standard library only, zero third-party packages. Every AI chat app I tried was either an Electron shell wrapping a web app, or a cloud subscription that owned my data. Electron apps eat RAM like crazy and they send your prompts to some server. The cloud ones just keep your data on their servers. I wanted something that ran on my Mac, used my local models (or cheaper cloud options), and actually felt like a native app. So I built JoeBro.
The Backend: One Python File, Zero Dependencies
The entire backend is a single file. No pip install. No venv. No node_modules. No requirements.txt. It opens an HTTP server and talks to Ollama running on your machine.
Here is the core loop. Everything else is just routing and tool dispatch:
class JoeBroHandler(BaseHTTPRequestHandler):
def do_POST(self):
body = json.loads(self.rfile.read(int(self.headers['Content-Length'])))
messages = body['messages']
tools = body.get('tools', [])
response = self.query_ollama(messages, tools)
self.send_response(200)
self.end_headers()
self.wfile.write(json.dumps(response).encode())
That is it. One file, one port, one running process. Clone the repo, run python3 joe.py, and you have a backend. It discovers available models from Ollama automatically once the endpoint is configured. It formats tool calls into the OpenAI-compatible schema that most local models understand. It handles streaming responses and thinking tokens.
I know people will look at a single-file backend and ask why it is not split into modules. Here is why it matters.
No dependencies means you do not fight Python versions. You do not debug broken pip installs. You do not maintain a requirements.txt that drifts out of sync. You do not set up a venv just to run 500 lines of code. The backend works on any machine with Python 3, full stop. I can run it on my Mac, copy it to a Raspberry Pi, or throw it on a headless server and it just works. And because it is one readable file with no dependencies, you can audit the whole thing in an afternoon. I would encourage you to.
The Swift app launches the backend process automatically when you open JoeBro. It is bundled inside the .app, spawned as a child process on launch, and killed on quit. It binds to 127.0.0.1:8765 and is never exposed to the network. You never think about it.
But you can also point the frontend at a backend running somewhere else entirely. I host mine on my Raspberry Pi 5 over tailscale to allow tasks to run at anytime without having to keep my laptop open. Open the app, plug in the server address, and I get all the same features without burning laptop battery. You could do the same with a cheap VPS or an old machine at home.
You can also use cloud models if you want. The settings panel has a field for any OpenAI-compatible API key. Drop in a DeepSeek key, a Groq key, or a local model. The app does not care. It talks to whatever backend you point it at.
The Frontend: Native macOS with Swift + WebKit
No React. No Electron. No bundler. Just Xcode.
The frontend is a native macOS app built with Swift and WebKit. Here is what that means in practice:
- Memory usage is way lower than Electron. A ChatGPT Electron client can eat 500MB plus just to show a chat window. JoeBro sits at around 60MB.
- It feels like a real Mac app. Native menus, native window management, native keyboard shortcuts. Cmd+W closes the window. Cmd+, opens preferences (even SF symbols). It responds instantly because it is not fighting a browser engine.
- Three-column layout on larger screens. Chat is in the center. A conversation list is on the left. An editor on the right to work directly in documents or code with your agent, or simply to read PDFs.
- Just about any file type is editable with JoeBro, and HTML and SVGs can render directly in the sidebar in view mode.
- Deep theming. The whole UI is an adaptive glass interface that sits over whatever wallpaper you choose. Drop in any image and the panels become translucent glass over it. There is a ◐ button in the sidebar footer that lets you tune how much glass you see. If you prefer something simpler there are built-in solid colour themes too. Your accent colour follows the system so it always feels cohesive.
The WebView renders a clean chat interface with message bubbles, inline code formatting, and markdown rendering. The Swift layer handles all the native stuff like window management, file dialogs, settings panels, and communication with the Python backend.
Built for Everyone, Not Just Developers
Most AI tools assume you know what you are doing. APIs, tokens, rate limits, endpoint URLs, environment variables. It is exhausting.
JoeBro works the other way. Download a model, pick it from a dropdown, start typing. The agent tools are just toggles. You do not need to know what MCP stands for. You do not need to edit a config file. Flip a switch and the model can read your files, check your email, or search the web. The permission system handles the rest.
If you are more technical, the app does not get in your way either. Point it at a remote server. Paste in an API key. Run a custom model. The full local API is on 127.0.0.1:8765 if you want to script against it. It bends both ways.
I built it so my non-technical friends could use local AI without calling me to fix something. It just works.
The Privacy Angle
This is the whole reason JoeBro exists.
It is 100% offline. No telemetry, no accounts, no cloud. You do not even need an internet connection after you have downloaded your models. No API keys. You never give your credit card to anyone. Every model runs on your hardware via Ollama. No data leaves your machine. Your prompts, your files, your conversations are all local. Your data is one SQLite file. Back it up with cp. If you unplug your Ethernet cable, JoeBro works exactly the same.
Right now companies like OpenAI and Anthropic are pushing customers toward pay-per-use pricing as costs surge. Every query costs money. Every feature is behind a subscription. JoeBro is the smart and private option. It gives you the same functionality as proprietary frontier apps, and soon more. All local, all yours, no meter running.
The Agent System
LLMs are powerful, but the vast majority of people, especially those doing non-technical work, never move beyond copy/pasting from ChatGPT or Claude. JoeBro has an agent mode that lets the model use tools to actually do things.
Flip the toggle under the message box to agent mode and the model can:
- Read and write files in your bound project folder. Work directly in your .md and .docx, and just about any other file type you can think of, right there with your agent.
- Run terminal commands if you enable the terminal toggle. The model can run Python scripts, check disk space, grep through logs. Output comes back into the conversation.
- Search the web for current information.
- Run deep research on any topic. The model pulls from multiple sources and synthesises a full report, not just a quick search result.
- Manage your email using IMAP. It can list, read, send, archive, and delete emails.
- Manage your calendar by creating events (directly through macOS Calendar integration or through CalDAV).
- Save and recall memories about you, so it remembers your preferences across conversations.
- Run scheduled tasks like daily email summaries or weekly audits of skills and memories.
There is also a thinking/fast toggle for those who are economically minded with their tokens.
Each capability has a permission level. You can set a session to sandbox (safe, no writes), read-only (look but don't touch), or full access (everything allowed). Terminal commands need full access and the terminal toggle on. Whether these actions need to be authorised or not is also toggleable in settings.
The app also has a chat mode where no tools are available at all. The model just talks, perfect for simple writing help etc.
The Brain: Skills, Tasks, and Memories You Control
JoeBro learns from you over time, but you are in full control of everything it knows. There is a dedicated tab where you can see, add, edit, and delete every skill, task, and memory on your own terms.
Memories are facts about you — your preferences, your setup, things you have told the model that you want it to remember across conversations. You can add them manually whenever you want, or let the model add new ones autonomously. Either way, you see the full list, you edit what is wrong, and you delete what is not useful.
Skills are reusable instructions that teach the model how to handle specific tasks. They can be simple prompts or multi-step workflows. The model auto-learns skills from your conversations with low confidence at first, so they only stick if you actually use them. But you can also write your own skills from scratch, edit existing ones, delete the ones you do not need, or even upload standard format skills as .md files.
Tasks are scheduled actions that run on a timer — daily email summaries, weekly skill audits, monthly cleanups. You set the schedule, you choose what runs, and you turn them off whenever you want.
There are weekly audit tasks that clean up skills with low confidence and unused memories by default. The stuff you actually use sticks around. The stuff you ignore gets cleaned up. But nothing happens without you being able to see it and change it.
Settings: Clean and Minimal
The settings panel (Cmd+,) has four sections:
- Models — pick which local model to chat with. JoeBro auto-discovers everything Ollama has pulled. No typing endpoints, no config. You can also paste an API key for cloud models.
- Appearance — change background or colour theme.
- Link email and calendar — connect email through IMAP and calendar through macOS (one click) or CalDAV directly in settings.
- Updates — JoeBro can update automatically through Sparkle.
That is it. No account settings, no subscription page, no telemetry consent form.
Call to Action
JoeBro is free, open source, and GPLv3 licensed. The whole thing stays open so forks stay open too. If this sounds like your kind of thing:
Star the repo on GitHub: github.com/joexk1/JoeBro
Download the v1.0 .dmg file for a plug and play experience and connect a cloud API.
Or clone it, open the Xcode project, hit Build. That is it. No containers to pull, no compose file, no port forwarding, no reverse proxy. You need Xcode and Ollama. That is it.
Open an issue or start a discussion. This is the first time it has been out in the wild. Happy to answer questions.
No signups, no newsletters, no "join the waitlist." Just a repo and a Python file.
Top comments (0)