Alpha · Phase 1 · Local-first

Point it at your GPU.
It figures out the rest.

A desktop studio for local and API-based language models — chat, agentic PhiloBots, long-term memory, built-in search, and a unified marketplace. Local-first, not network-isolated: models, chats, and memory stay on your machine, and every feature that calls out is documented, not assumed.

View on GitHub Read the docs

Go backend Flutter frontend AGPL-3.0 Phase 1 alpha

philoengine — hardware fit

Why another one

The part you never see is the one that took the most work.

Hardware-aware engine

Detects RAM and GPUs, estimates the memory footprint per model, then proposes a context size and runtime it can actually start — GPU, GPU-plus-RAM, or CPU fallback.

PhiloBots with tools

Custom assistants with their own prompt, style, and trigger words. Project-aware file tools ask for permission before touching anything, and changes arrive as readable diffs.

Long-term memory

Recall across sessions, kept separate per user and per project — SQLite full-text search plus vector retrieval, with deterministic local embeddings by default.

Built-in text search

Search DuckDuckGo, Brave, Google, Bing, or Wikipedia from inside a chat, then fetch and condense a page to Markdown, guarded against local-network targets.

Unified marketplace

Hugging Face downloads and OpenRouter/Featherless models side by side. Local candidates show quantization, estimated resource use, and a hardware-fit verdict.

Fails gracefully, in the open

GPU → CPU, smaller context, alternate KV-cache type. Each fallback step is shown, never hidden behind a silent retry.

How it works

Three layers, one binary decision at the bottom: does it fit?

Flutter desktop app Material 3 · DE/EN · chat, engine, bots, memory, marketplace

HTTP/JSON + SSE · 127.0.0.1

Go backend (Fiber) hardware planner · philobot · memory · search · marketplace · news · benchmark

spawns & supervises

llama.cpp · vLLM · Transformers local inference runtimes

Both application servers bind to 127.0.0.1 by default. The main desktop flow runs over HTTP/JSON and server-sent events — only the Skills client currently uses a limited gRPC surface. Local application data lives under backend/data/.

Local modelInference stays with the local backend and worker

API modelPrompt and settings go to the selected provider (OpenRouter or Featherless)

Search / News / BenchmarkThe selected or public source for that feature

Model downloadHugging Face, or the configured provider

Update checkGitHub release infrastructure

Worth knowing News and Benchmark refresh in the background on their own schedule, and PhiloBot's file-tool checks are guardrails, not an operating-system sandbox. Read the privacy & network doc before pointing PhiloBot at anything sensitive.

Screenshots

Every module, built for the same question: what actually runs here?

PhiloEngine selecting and starting a model, then retrying with a safer context size — A requested 64k context doesn't fit, so the engine retries at 32k — and keeps the decision visible.

PhiloEngine model studio with hardware telemetry — Model Studio — plan, configure, start, and observe local model instances.

PhiloEngine marketplace with model and hardware filters — Marketplace — compare local downloads and API models in one responsive grid.

Current scope

What's usable today, what's alpha, and what's intentionally still locked.

Phase 1 — available

Chat, Engine, Marketplace, authentication, user preferences, PhiloBots, memory, text search, settings, skills administration.

News — alpha

AI and technology feeds with search, filters, and saved articles.

Benchmark — alpha

LMArena text leaderboard with ranking, model details, and comparison views.

Phase 1 — active development

Improve existing functionality, fix bugs, refine frontend design and usability, strengthen verification, expand documentation.

Phase 2 — planned

Extend current features, with usable connections to external servers from Chat and Engine.

Phase 3 — locked preview

Guided full fine-tuning, fine-tuning, and quantization workflows.

Phase 4 — locked preview

Image and video generation, plus a game-development workspace.

Phase 5 — long-term direction

Opt-in sharing of self-hosted models and compute capacity, keeping PhiloEngine itself free and open source.

No promised dates for future phases — the full roadmap separates working functionality from previews and planned work. Always check the notes for the release you actually install.

Get started

Two ways in — pick the one that fits.

Quick install no build tools needed

Download the Quick Install archive for your platform from the latest release — filenames end in -quickinstall, not the similarly named update archive. Extract it once and always start the top-level launcher: it verifies the published size and SHA-256, installs updates atomically, and can roll back a version that fails its health check.

# extract, then run:
./myphiloengine        # Linux / macOS
myphiloengine.exe      # Windows

From source for developers

Complete the one-time setup in the installation guide, then start backend and frontend together with the project launcher. On a clean main checkout it applies a safe fast-forward update first — it never overwrites local changes.

git clone https://github.com/kuchenboss/MyPhiloEngine.git
cd MyPhiloEngine
./start.sh

No GPU? Add an OpenRouter or Featherless key under Settings → Providers and start a model from the marketplace instead.

OSQuick Install: Linux x64, Windows x64, macOS (Apple Silicon). Other setups via source.

Flutter3.44+ (Dart 3.12+) — source checkout only

Go1.25+ — source checkout only

Python3.x — source checkout and local runtime installation

GPUOptional — CPU inference works, just slower

Your machine already has the hardware.
This is the part that reads it correctly.

View on GitHub Download a release

Point it at your GPU.It figures out the rest.