Loading repository data…
Loading repository data…
siyamlk / repository
End-to-end AI-powered desktop coding assistant built with React, TypeScript, Tauri, Groq API, SQLite, and secure OS Keychain integration for code generation, debugging, and intelligent developer assistance.
A desktop AI coding companion built around the idea that understanding should come before answers.
I built CapyCode after noticing something about the AI tools I used every day.
Most coding assistants are incredibly good at producing answers, but they often encourage you to move on before you've had the chance to understand why something works.
That made me wonder:
What if an AI coding assistant behaved more like a patient companion than a code generator?
That question became CapyCode.
Rather than focusing only on generating code, CapyCode lives on the desktop as a lightweight companion that adapts to conversations, helps investigate bugs, celebrates progress, remembers previous chats, and lets users connect their own AI provider.
What started as a simple idea gradually became an opportunity to explore desktop application development, conversational AI, state management, persistence, and designing software with a little more personality.
Along the way, I experimented with ideas like mood-driven interactions, local conversation history, provider abstraction for different LLMs, and creating an experience that feels less like another chat window and more like a companion that quietly stays alongside your workflow.
While CapyCode is still evolving, building it has been just as much about learning how these systems come together as it has been about the final application itself.
From the beginning, I wanted CapyCode to feel like something that stayed with me while I worked rather than another tool I constantly switched to. That idea shaped almost every design decision, from how conversations are remembered to how the companion responds throughout a coding session.
Coding sessions rarely begin and end with a single question. CapyCode stores conversations locally so they can be revisited later, while intelligently managing the amount of context sent to the AI to keep responses efficient.
Rather than remaining static, CapyCode responds to the flow of a conversation through a lightweight mood system. The goal isn't to interrupt your workflow, but to make interactions feel a little more expressive.
Small interactions were just as important to me as the conversations themselves. Instead of disappearing into the background, CapyCode stays nearby, remembers where you left it, and is designed to feel like a consistent companion throughout a coding session.
Today, that includes:
Although CapyCode appears simple on the surface, it brings together several ideas I wanted to explore while building it. Rather than centering everything around a single chat component, the application is split into independent pieces responsible for conversations, AI providers, persistence, and companion behaviour.
At a high level, CapyCode looks like this:
React + TypeScript
│
Chat Interface
│
Zustand Store
│
┌──────────────────┼──────────────────┐
│ │ │
Mood System Conversation Layer AI Provider Layer
│ │ │
│ SQLite Groq / Gemini
│
Desktop Companion
Each layer has a single responsibility.
Keeping these responsibilities separate made it much easier to add new providers, improve the companion's behaviour, and expand the project without constantly rewriting existing code.
As CapyCode grew, I wanted each part of the application to have a clear responsibility instead of collecting everything into a handful of large files. The project is organised around independent modules that handle the interface, companion behaviour, AI integration, persistence, and desktop functionality.
CapyCode
├── src/
│ ├── components/ # Chat interface, companion, settings and UI
│ ├── store/ # Global state and mood management
│ ├── lib/
│ │ ├── ai/ # AI providers, context management and streaming
│ │ ├── bridge.ts # Desktop bridge utilities
│ │ └── moodMachine.ts # Companion behaviour and state transitions
│ ├── db/ # SQLite schema, migrations and repositories
│ ├── assets/ # Companion artwork and static assets
│ └── styles/ # Global styling
│
├── src-tauri/
│ ├── src/ # Rust backend
│ ├── capabilities/ # Tauri permissions and capabilities
│ ├── icons/ # Application icons
│ └── tauri.conf.json # Desktop configuration
│
├── docs/ # Documentation
└── .github/ # CI workflows
The project is intentionally organised into loosely coupled modules so that the interface, AI providers, persistence layer, and companion behaviour can evolve independently as CapyCode grows.
Every project involves balancing simplicity, performance, and flexibility. CapyCode intentionally makes a few engineering trade-offs to keep the application lightweight today while leaving room for future improvements.
To reduce token usage and API costs, CapyCode doesn't send the entire chat history with every request. Instead, it builds a context window using only the most relevant recent messages.
This keeps responses fast and efficient, but extremely long conversations may gradually lose older context until a long-term memory system is introduced.
CapyCode doesn't include built-in AI access. Instead, users connect their own API keys and choose the provider they'd like to use.
Because of this, response quality, available models, quotas, and rate limits depend entirely on the selected provider rather than CapyCode itself.
The companion follows a predefined event-driven mood system. It can react to events such as debugging, project discussions, achievements, frustration, and inactivity, but it doesn't yet learn from previous sessions or adapt its personality over time.
CapyCode is built with a cross-platform architecture using Tauri.
The application currently targets Windows, while the same codebase is designed to support macOS as development continues.
CapyCode started as a way to explore a different kind of AI coding experience, but I don't see this as a finished project. There are still plenty of ideas I'd like to experiment with as I continue building it.
Don't want to build from source? Grab the latest installer for your OS from the Releases page.
| Platform | Look for |
|---|---|
| Windows | the .exe installer (or .msi) |
| macOS (Apple Silicon) | the aarch64.dmg |
| macOS (Intel) | the x64.dmg |
The exact filename includes the version number and updates with every release — for example, the current release is:
CapyCode_0.1.3_x64-setup.exe — Windows installerCapyCode_0.1.3_x64_en-US.msi — Windows MSI (alternative)CapyCode_0.1.3_aarch64.dmg — macOS Apple SiliconCapyCode_0.1.3_x64.dmg — macOS IntelA note on the warnings you'll see: these builds aren't code-signed yet — that costs money I haven't put into the project at this stage — so your OS will flag them as coming from an unverified developer. The app itself is safe; here's how to get past the warning.
Windows — you'll see "Windows protected your PC" (SmartScreen). Click More info, then Run anyway.
macOS — you'll see a warning that the app "can't be opened because it is from an unidentified developer," or that it's "damaged." Right-click (or Control-click) the app → Open → confirm Open in the dialog that appears. If macOS still refuses, run this once in Terminal:
xattr -cr /Applications/CapyCode.app
Signed, notarized builds are on the roadmap once there's budget for an Apple Developer account.