Documentation

Getting Started

Documentation Home

Quick Start

Installation

System Requirements

First Run Wizard

Build from Source

Core Concepts

What is Memo?

How RAG Memory Works

Architecture Overview

Backend Architecture (Go)

Frontend Design (Flutter)

Data Layer & Persistence

Design Philosophy

Features

Features Catalog

Chat & Conversation

RAG Semantic Memory

Model Management

Llama.cpp Integration

Vector Search Logic

Incognito Mode

Multimodal (Vision & Voice)

Performance

Advanced Features

Agent Mode

Orchestra Mode

External Providers

Proactive Learning & Calendar

Cloud Sync

WhatsApp Integration

Mobile Companion App

Backup & Restore

Development

Developer Guide

API Reference

CGO Build Flags

Build & Packaging

Contributing

Default System Prompt

Reference

Configuration Reference

Advanced Settings

Technical Deep Dive

UI Features

Security

Resources

Troubleshooting

Known Issues

Resolved Issues

FAQ

Release Notes

Build and Packaging

How to build Memo from source and create distributable packages.

Backend Build

CGO_ENABLED=1 go build -o memo .

The output is a single binary named memo (or memo.exe on Windows). This binary contains the Go backend server only — the Flutter frontend is a separate build step.

Frontend Build

cd frontend
flutter build linux --release      # Linux desktop
flutter build windows --release    # Windows desktop
flutter build macos --release      # macOS desktop
flutter build apk --release        # Android companion app
flutter build ios --release        # iOS companion app

Combined Distributions

The desktop app is distributed as a single package containing both the Go backend and the Flutter frontend. The release build script handles combining them.

Linux Packaging

`package_linux.sh`

The Linux release is packaged via package_linux.sh:

./package_linux.sh

This produces a .tar.gz archive containing:

memo (backend binary)
memo_frontend/ (Flutter Linux build output)
vec0.so (sqlite-vec extension)
config/config.yaml (default config)

AppImage (Planned)

An AppImage format is planned for future releases to provide a single-click Linux distribution that bundles all dependencies.

Windows Packaging

Windows releases are built via GitHub Actions CI and produce a .zip archive:

memo.exe (backend binary)
memo_frontend/ (Flutter Windows build output)
vec0.dll (sqlite-vec extension)

An NSIS-based .exe installer is the primary Windows distribution format:

Memo-Setup-v3.1.0.exe

Distribution Formats

Format	Platform	Status
`.exe` installer	Windows	Shipped
`.tar.gz` portable	Linux	Shipped
`.AppImage`	Linux	Planned
`.deb`	Linux	Planned
`.dmg`	macOS	Shipped
`.apk`	Android	Shipped (companion app)
`.ipa`	iOS	Planned (companion app)

Release Script

./build_releases.sh

This script orchestrates full platform builds and produces all distribution archives. The script handles:

Cleaning previous build artifacts
Building the Go backend with CGO enabled
Building Flutter for each target platform
Copying sqlite-vec extension binaries
Packaging into platform-specific archives
(Optional) Code-signing for macOS

Version Bumping

Update the version string in main.go and in the frontend's pubspec.yaml before building a release.