NomiFun Desktop：完全开源、本地优先的超级 AI 工作站

A no-holds-barred, fully open-source, local-first super AI workstation.

Rich, inventive capabilities and serious productivity gains —
with all your data staying on your own machine. Safe for individuals and enterprises, free to commercialize, open to audit.

English · 简体中文

🌐 Website ·  📖 Docs ·  🚀 Get started ·  📦 Releases ·  🇨🇳 Gitee source ·  China mirror ·  发版手册 ·  💬 Community

Important

Public-interest open-source and data-risk notice: NomiFun is a public-interest open-source project. The maintainers do not assume responsibility for user data loss, corruption, or unrecoverable damage during iteration. Back up your data before upgrades, migrations, experimental features, or real production use.

NomiFun is everything you imagine an AI workstation to be — and it runs on your terms. One React frontend and one Rust backend give you an evolving desktop companion, an unattended automation platform, a unified knowledge base, native computer- and browser-use, and an open capability bus that any agent can drive. No NomiFun cloud account. No telemetry. No subscription. Your workspace data stays local; requests go to the model services you configure, including model invocation, model catalogs, and quota queries.

The product name is NomiFun. Lowercase nomifun is used only for code identifiers, crate names, environment variables, and repository paths.

NomiFun open-source product family

NomiFun has four runtime projects plus NomiFun Portal, the canonical documentation home. Desktop is the local AI, data, model, Agent, task, and tool hub; Mobile and the Xiaozhi robot connect to capabilities that you explicitly enable, while Net Infra provides an optional, self-hosted cross-network relay. Desktop also hosts Unified Plugins, so a locally authored Plugin can keep using the same governed runtime and capabilities instead of becoming an isolated demo.

Connect the four projects

1. Run Desktop, configure the models/companions you need, and keep all data on that machine.
2. For Mobile, open Remote & Open → WebUI access, start the listener, and scan the short-lived, one-time QR code from the Mobile app. On a LAN, Mobile connects directly to Desktop with no NomiFun cloud relay. Desktop remains the authority and server; the phone is an authenticated client, so model credentials and the durable data set do not need to be copied to the phone.
3. For Xiaozhi, build and flash the Yuntai firmware, then follow the companion Remote control → Robot connection flow in Desktop to bind the device.
4. When access must cross networks, self-host NomiRelay and nfagent, then point Mobile at the relay business endpoint. Mobile never receives relay admin credentials, and Desktop remains the application-data authority.

Only enable remote interfaces on networks you trust. The Desktop guides above document authentication, LAN exposure, and deployment boundaries.

One local hub, many interaction surfaces

This is not a collection of unrelated clients that happen to share a logo. Desktop owns the durable state and executes models, Agents, requirements, tools, knowledge, companion memory, and Skills. Mobile is a direct LAN control surface; Xiaozhi is a voice-and-motion hardware surface; Unified Plugins are interactive software surfaces created and hosted by the same Desktop installation; Net Infra is an optional transport layer rather than another application backend. The result is one governed capability graph with multiple ways to reach it, rather than separate clouds, accounts, credentials, and copies of user data.

Read the NomiFun product ecosystem architecture for the trust boundaries, communication model, differentiators, and product innovation timeline. Simplified Chinese: product-ecosystem.zh.md.

✨ Why NomiFun

🔒 Local-first, by design

Data security is not a setting in NomiFun — it is the architecture.

• All data is local. NomiFun never proactively sends your data anywhere. Model-service requests go to the services you explicitly configure, including model invocation, model catalogs, and quota queries. See the FAQ for other network features you can choose to use.
• Safe for anyone who cares about data. Individuals and enterprises with strict data-handling requirements can use it with confidence. The code is fully open and open to audit.
• We cut features to keep this promise. To guarantee your data stays yours, we deliberately dropped several advanced, genuinely fun feature designs. Everything here is in service of letting users — and developers — relax.
• No ads. No membership tiers. The official project conducts no commercial operations. We will never charge for any feature of this project, and the official project does not operate any paid services. The only expense is model tokens, which you pay directly to the model service you choose.

See SECURITY.md for the deployment threat model and responsible-disclosure policy.

🖼️ See the product

🎬 Demo videos: China: Bilibili  |  International: YouTube

_{Workspace · conversations, Agents, tasks, tools, and connected devices in one desktop}

_{Creative Studio · persistent Canvases, media node composers, reusable prompts and assets, and templates}

Multi-model management · providers, capabilities, and task-aware routing	Desktop companions · persona, memory, models, and remote control
Skills Hub · reusable, governed Agent capabilities	More Creative Studio screens follow below The numbered gallery covers the current Canvas, asset libraries, templates, Assistant, skills, and companion workflow.

_{Captured from NomiFun Desktop 0.8.0 on October 8, 2026, with example conversations, generated images, assets, and templates. See the screenshot manifest for source, synchronization, and usage details.}

🎨 Creative Studio — the new creation surface

Creative Studio is a new, focused creation surface inside NomiFun Desktop—not a single marketing screen. The numbered gallery follows the product surfaces a creator can actually open: persistent Canvases with media-node composers, Prompt Center, My Assets, private templates and AI Create, multi-image series, Canvas Assistant, explicit Creative Studio skills, and an optional native desktop companion.

Canvas workspace · a brand brief and three generated visuals, ready to reuse in assets and templates
Canvas Library · create, open, manage, import, and export persistent Canvases
Prompt Center · a searchable, attributed prompt catalog with categories, tags, copy, and save-to-assets actions	My Assets · reusable text, image, video, and audio assets with filters, collections, tags, and pickers
Template Studio · private single-image and multi-image-series templates with variables and exact model settings	Template Editor · reusable variables, prompts, exact models, aspect ratios, and resolution
Companion workspace · companion figure, persona, model, memory, Skills, and the Show on desktop control	Native desktop companion · quick replies and a real coffee-brand tagline

The 0.8.0 gallery covers the Canvas library and workspace, prompts, assets, templates, and companions. Replaced screenshots and captures of retired standalone workbenches have been removed. The Skills Hub capture above shows the Creative Studio skill packages as reusable capabilities. All captures should represent the running product, not a mockup or an invented capability. See docs/images/SCREENSHOTS.md for the capture manifest.

For the user-facing guide, see docs/guides/creative-studio.md; the same content is mirrored on NomiFun Portal.

🚀 Feature highlights

NomiFun Desktop has grown from an Agent chat client into a local, extensible AI workspace. Its major product surfaces now share the same conversations, models, memory, tools, permissions, and execution runtime:

🐾 Desktop Companion — it grows with you

Product guide: docs/guides/companions.md · Portal mirror

The companion you talk to every day quietly becomes the partner who gets you.

• Make it yours. Upload a custom companion figure (DIY), or pick from an independent figure library decoupled from any single companion.
• A family, not a hive mind. Run multiple companions side by side, each a complete individual with its own chat model, persona, memory, and domain knowledge bases. Memory belongs to exactly one companion — nothing you tell the work companion leaks into the one you chat with at home.
• A place of their own. Companion chat, identity and management now live together in Desktop Companion. Work Sessions stay focused on projects and tasks, while the native quick window lets you switch companions and reply without opening the full workspace.
• It learns you (opt-in, on by default after a one-time consent). A background learner distills your usage into durable memories; a deterministic evolution engine mines your recurring multi-step tool sequences into draft skills it proposes for your review. Memory is fully visible and editable.
• Skills it writes itself. Companions distill their own skills out of real work and discuss them with you before anything is kept.
• A super gateway, not just a buddy. Each companion is a complete, independent individual that can connect to multiple IM channels. From anywhere with a network and a chat app, message your companion to drive your computer for you. Each companion can fully operate the desktop's capabilities.

🤖 XiaoZhi robot — give your companion a physical presence

Product guide: docs/guides/xiaozhi-robot.md · Portal mirror · Firmware: nomifun-xiaozhi-yuntai

Connect a compatible XiaoZhi ESP32 robot directly to NomiFun over your LAN. The robot supplies the microphone, speaker, display, servos, and device-side MCP tools, while NomiFun supplies the companion's persona, models, memory, ASR, TTS, sessions, and tool coordination. Setup is built into each companion's Remote control → Robot connection page: copy its OTA address, enter the six-digit activation code shown by the robot, and bind the device to that companion.

🧩 Unified Plugins — create and run governed local software

Create a Plugin through Chat or import a package directory/ZIP. Both sources enter the same validation and install_artifact path. A local Plugin points to one active immutable Artifact and one generation DataRoot; optional UI and Service entrypoints cover UI-only, headless, and mixed Plugins without separate product models. Actions bind directly to Agent, Desktop, and Automation points through stable plugin:<plugin_id>/<action_id> identities.

The unified SDK exposes SQLite, KV, Files, memory-only Cache, Config, Credential references, Host capabilities, and cross-Plugin Actions. Preview uses the same Bridge and storage adapters against a temporary DataRoot. Package export excludes user data; Backup includes current data and non-secret config but never Credential plaintext. See the Plugin Platform architecture.

🎨 Creative Studio — focused creation on an infinite canvas

Product guide: docs/guides/creative-studio.md · Portal mirror

Creative Studio is a persistent creative document system, not a disposable whiteboard. An infinite Canvas stores text, image, video, audio, timeline, config, and group nodes. Media nodes own the visible creation surface; config nodes keep the exact provider/model/task, typed parameters, ordered inputs, task state, and results auditable. The Canvas Assistant proposes typed graph operations, validates them fail-closed, and waits for Apply to Canvas—it never silently mutates the document or runs generation in the background.

Canvas media nodes cover the full generation matrix: Image supports T2I and I2I with real reference assets, Video supports T2V and one-image I2V, and audio creation runs through Canvas audio nodes and TTS. Prompt Center provides searchable, attributed prompt collections, while My Assets stores reusable text, image, video, and audio assets with kind filters, collections, tags, metadata, and pickers. Reference images are hydrated by asset ID, so reloads never reuse stale browser objects.

Canvas Assistant turns a creative request into a Canvas-scoped proposal, and the composer requires explicit selection of 1–3 Creative Studio skills: Canvas planning, Organize layout, or Template design. These skills shape the proposal; they are not inferred from arbitrary prompt wording, and applying a proposal still requires the user’s explicit confirmation.

Template Studio turns prompts, variables, exact model bindings, and output plans into private reusable templates. AI Create produces one strict draft for review; Apply opens an in-memory editor draft and only explicit Save persists it. Multi-image series can require review before generation.

Every operation carries an exact enabled { providerId, model, task } identity: chat for Assistant and template drafting, image_generation/image_edit for T2I/I2I, video_generation for T2V/I2V, and speech_synthesis for TTS. Canvas writes use revision-based CAS; conflicts stop automatic saving instead of overwriting newer work, and task history reconciles the exact owner after reload. Canvas ZIP v3 exports the validated document and referenced asset closure while the v1/v2 readers remain supported.

🧠 Multi-Agent execution cluster — plan, schedule, supervise

Start from a normal Agent conversation. When a task deserves specialization or parallel work, NomiFun creates one persistent AgentExecution aggregate linked to that Conversation, plans a dependency graph, and schedules ready steps across delegated Agents while the lead Agent remains the control point.

• Dependency-aware scheduling. Independent steps can run concurrently; blocked steps wait for their prerequisites instead of racing on incomplete context.
• Per-step preflight control. Override a delegated Agent's model and add a preset brief before it starts; completed or failed steps can be retried with the same configuration.
• Review before execution. Approval-enabled collaboration pauses after planning and presents the graph in the conversation so you can adjust it before work begins.
• Live, real transcripts. Follow state changes and open any step's actual Agent conversation, then return to the lead conversation to keep supervising the whole cluster.
• Recovery is part of execution. Persisted state supports retry and restart recovery instead of reducing a cluster run to disposable background messages.

🤖 Unattended automation — Requirements + AutoWork + IDMM

Product guides: Requirements & AutoWork · Intelligent decision (IDMM)

You give the orders; NomiFun reliably does the work.

• Requirement platform — a CRUD store with ordered rotation, a board/kanban, tags, and per-item claim.
• AutoWork — claims pending requirements, drives a turn, rotates to the next, and renews leases while a turn is in flight. Targets are canonical AgentSessions bound to a saved Agent.
• IDMM (Intelligent Decision-Making) — per-session supervision that keeps agents alive through provider faults and decision stalls, with a no-LLM rule tier and a sidecar backup-model tier, stacking on top of AutoWork.
• Notify out — completion notifications to Lark/Feishu custom bots, Slack, and HTTP webhooks.

📚 Unified Knowledge Base

Product guide: docs/guides/mcp-and-skills.md · Portal mirror

Pull the knowledge scattered across your system into one managed, trackable place.

• Centralized management & tracking — create, mount, and track consumers across conversations, terminals, and companions.
• Safe write-back — a code-enforced, per-surface write policy. Every mount picks its write-back disposition: manual (the default — nothing is written back unless you ask for it in the conversation) or automatic (the agent decides on its own, and only writes what it is confident is durably worth keeping). Either way an update appends to the existing document under compare-and-swap, so a write-back can add to the text you curated but never overwrite it.
• Real-time URL snapshot — turn any web page into a knowledge source (SSRF-guarded fetch, HTML→Markdown), in snapshot (persisted, re-fetchable) or live mode.
• Scoped retrieval — agents call a knowledge_search tool whose scope is decided server-side and cannot be widened.

🖥️ Native Computer Use & Browser Use (desktop build)

Product guide: docs/guides/computer-browser-use.md · Portal mirror

Self-built, in-process Rust — no Playwright, no Node, no third-party automation daemon. More capable, faster, and far cheaper on tokens, with fine-grained control and fully open source for you to extend.

• Computer use — accessibility tree + Set-of-Marks overlay + OCR, steering the model to act on real UI elements instead of guessing pixels. macOS (AXUIElement + Vision OCR) and Windows (UI Automation) are complete; Linux (AT-SPI2) is partial.
• A real browser inside the conversation — the desktop embeds native WebView2 on Windows and system WKWebView on macOS 14+ (Apple Silicon and Intel); Linux is deferred. The user and the Agent share one live page with tabs, navigation, forms, history, isolated sign-in state, WebSocket and HMR. On macOS, Agent interaction uses semantic page actions for ordinary buttons and forms; advanced gestures and automatic file transfer are explicitly unsupported. See the platform capability matrix.
• One simple input rule — while the Agent is running, browser input belongs to the Agent and the user watches the real interaction. When the turn ends, the user can operate the page directly. There is no pause-and-take-control workflow.
• Frontend testing without a separate test product — an enabled Agent can observe rendered elements and use real mouse, keyboard, drag, upload, download, and dialog interactions to test an app it is building. There is no Browser console, problem list, test-step panel, or special test mode.
• Conversation-owned state — each persistent conversation has its own browser profile and tabs. The Browser opens from that conversation rather than a global management page or Browser settings center; site data and downloads stay in the small in-context browser menu.
• Optional web research — the web.research capability module gives models without provider-native search a separate, selectable public-web research surface. It runs in an isolated background browser and never reads session tabs or sign-in state.
• Optional attached-Chrome provider — an Agent session's browser capability can be served by an already-running, signed-in Chrome on Windows (/api/browser-providers/attached-chrome). NomiFun does not launch Chrome, import profiles, or move credentials into the embedded browser.
• No hidden interactive fallback — isolated headless Chromium is reserved for local search and content rendering. Interactive Browser work always targets the native conversation surface, and failure to create that surface is reported instead of silently switching engines.

ℹ️ Computer/browser control ship with the desktop app. The headless web/server host omits them by design.

🌐 Open capability bus — MCP + REST

Product guide: docs/guides/remote-capability-api.md · Portal mirror

External agents drive NomiFun through a canonical remote-AgentSession surface — an explicit, token-scoped contract rather than a generic tool dump.

• MCP front door at /mcp (Streamable-HTTP, installation token) exposing exactly open, turn, observe, and cancel. Point Claude Code, Cursor, or your own agent at it and they drive durable AgentSessions.
• Canonical REST at /api/remote/{open,turn,observe,cancel} for clients that prefer plain HTTP over MCP.
• RemoteBindings managed locally at /api/remote-bindings pin which Agent/capabilities a remote token may open; WebUI remote access uses /api/webui/access-token.

🧩 One built-in agent, many models

Product guide: docs/guides/model-routing.md · Portal mirror

• Built-in nomi agent — no extra install, and the only conversation engine. Works with 26+ model providers/presets (OpenAI, Anthropic, Gemini + Vertex AI, AWS Bedrock, DeepSeek, OpenRouter, Moonshot/Kimi, Qwen/Dashscope, Zhipu/GLM, MiniMax, SiliconFlow, xAI, Volcengine/Doubao, and more) across 4 wire protocols, plus the New API aggregator gateway.
• One code path — every conversation runs the same engine, so capabilities, tool policy, approvals, and failover behave identically no matter which model you pick.
• Want Claude Code, Codex, or Gemini CLI? Run them in terminal mode — real in-app PTY sessions with NomiFun's capabilities injected through each CLI's own native config. See the Portal terminal guide.
• Everywhere — the native capabilities are available to the built-in agent, in the chat UI, and in the terminal.
• Graceful multimodal fallback — if a selected provider/model rejects image input, NomiFun strips the images, retries in the same conversation, and leaves an inline notice instead of killing the session.
• Per-model context tuning — override context-window limits per model when an upstream platform reports bad defaults or hides them, improving routing and long-context budgeting.

🔌 Multi-model control plane — providers, capabilities, and routing

NomiFun separates provider credentials from model records and capabilities. Extend the catalog with native providers, compatible protocols, custom base URLs, or local and self-hosted endpoints. Enter a model id directly, then configure independent routes when realtime, ASR, TTS, image generation/editing, video generation, embedding, or reranking needs a separate interface. Chat input and technical features require no capability checkboxes. Routing is task-aware, supports per-model context and output limits, and can fail over without pretending that every provider uses the same URL, protocol, or auth.

Model suggestions do not restrict manual entry. Independent tasks use their saved provider and protocol routes; Chat features depend on protocol support and actual provider responses rather than omitted capability tags. Creative Studio carries the exact { provider, model, task } identity into every media operation, so a same-named model from another provider is never substituted silently.

For your own providers, pick by region, price, quota, capability, and data policy, then add the credentials on Models & Agents. The following services are third-party offerings; their pricing, availability, rate limits, and data terms remain under each provider's control.

Provider	Start here	Good to evaluate
StepFun	Platform	Step models for Chinese, agentic, and cost-conscious workloads
Kimi / Moonshot AI	API keys	Long context, Chinese writing, coding, and general tasks
GLM / Zhipu BigModel	API keys	GLM models, general reasoning, coding, and enterprise integration
Doubao / Volcengine Ark	API keys	Doubao models and China-region cloud/enterprise workflows
Qwen / Alibaba Cloud Model Studio	API keys	Qwen models, DashScope, and Alibaba Cloud workflows
MiniMax / MinMax	API keys	MiniMax models, long-form text, multimodal, and voice capabilities
MiMo / Xiaomi	Website	MiMo models and Xiaomi ecosystem capabilities
DeepSeek	API keys	Reasoning, coding, and high value-for-money model calls
OpenRouter	API keys	Multi-model aggregation, unified billing, fallback routing, and comparison
Claude / Anthropic	API keys	Claude models, long-form work, coding, and the Claude Code ecosystem
GPT / OpenAI	GPT models · API keys	GPT models, OpenAI API, agent workflows, coding, and general-purpose tasks
Gemini / Google AI	API keys	Gemini models, multimodal work, very long context, and Google AI Studio

💻 Terminal mode — where third-party agent CLIs live

Product guide: docs/guides/terminal.md · Portal mirror

Run agent CLIs inside in-app PTY sessions. This is how Claude Code, Codex, and Gemini CLI are used with NomiFun: a real pseudo-terminal, the CLI's own auth and OAuth, its own approval prompts, nothing re-implemented. NomiFun injects native capabilities — knowledge search, requirement completion, and lifecycle hooks — into known CLIs through their own native config, so you keep full fidelity. Terminal sessions stay interactive; AutoWork targets canonical AgentSessions instead.

📱 NomiFun Mobile — direct to your Desktop

Product guide: docs/guides/webui-remote-access.md · Portal mirror · App: nomifun-mobile

No social platform or NomiFun cloud relay is required on a LAN. One-tap QR pairing gives the phone a short-lived, one-time login credential and connects it directly to the authenticated listener inside Desktop. Mobile then uses the same sessions, tasks, requirements, companions, models, and tools in real time; Desktop remains the data and execution authority. The phone is a connected, authenticated client, so it does not need a duplicate database or a second copy of your model credentials.

⚙️ Config once, use anywhere

Central hubs for Knowledge, Agent workbench & Skills, MCP, Models, and Open Capabilities — define them once, then select per conversation, terminal, channel, or companion. One source of truth, reused everywhere.

💬 11 IM channels

Product guide: docs/guides/channels.md · Portal mirror

Bind a companion to any of these and drive it from where you already chat:

Telegram · Lark / 飞书 · DingTalk / 钉钉 · WeChat / 微信 · Discord · Slack · Matrix · Mattermost · Twitch · Nostr · QQ Bot

🏗️ Architecture

One React frontend, one Rust backend, two host modes — and the same backend runs in-process in both.

At the product-family level, Desktop is also the hub for Mobile, Xiaozhi, Unified Plugins, and companion IM channels. See docs/architecture/product-ecosystem.md for the full communication, security, and innovation model.

There is no Electron shell, no Node web host, and no prebuilt backend handoff.

Repository map

apps/
  desktop/      Tauri 2 shell and desktop-only commands
  web/          standalone web host for API + SPA
crates/
  agent/        nomi-* agent engine crates: providers, tools, MCP, skills,
                memory, browser/computer use
  backend/      nomifun-* service crates: app composition, auth, database,
                sessions, MCP, knowledge, requirements, terminal, etc.
  shared/       cross-layer crates shared by agent and backend
ui/             React 19 + Vite SPA shared by desktop and web
docs/           technical docs, user/operator guides, architecture notes
packaging/      Linux deployment support for the web host

Start with docs/architecture/overview.md for the full system map. The Cargo workspace is defined in Cargo.toml.

🚀 Getting started

📦 Installers: use GitHub Releases first. Mainland China users can use the Baidu Netdisk mirror (shared as nomifun). You can also install from source or run the server with Docker.

Prerequisites

• Rust — stable toolchain, edition 2024
• Bun ≥ 1.3.13
• Recommended on PATH for full agent tooling: node / npm / npx, git, ripgrep

Desktop app (from source)

git clone https://github.com/nomifun/nomifun-desktop.git
cd nomifun-desktop
bun install

bun run dev      # develop with hot reload
bun run build    # build a desktop bundle for your OS

Web server (self-host)

bun run build:ui && bun run serve:web
# serves API + SPA on http://127.0.0.1:8787 (login required)

Docker (self-host the server)

The official image is published on Docker Hub: nomifun/nomifun-web. The examples below use latest, the stable rolling tag published on Docker Hub. For reproducible deployments, pin an explicit version or image digest.

# Pull and run the official image.
docker run -d \
  --name nomifun-web \
  --restart unless-stopped \
  -p 8787:8787 \
  -v nomifun-data:/data \
  nomifun/nomifun-web:latest
# then open http://<server-ip>:8787 and create the first admin

For unattended or internet-facing deployments, pre-seed the first admin before the port is reachable:

docker run -d \
  --name nomifun-web \
  --restart unless-stopped \
  -p 8787:8787 \
  -v nomifun-data:/data \
  -e NOMIFUN_ADMIN_USERNAME=admin \
  -e NOMIFUN_ADMIN_PASSWORD='change-me-to-something-strong' \
  nomifun/nomifun-web:latest

Compose can use the same official image:

services:
  nomifun:
    image: nomifun/nomifun-web:latest
    restart: unless-stopped
    ports:
      - "8787:8787"
    volumes:
      - nomifun-data:/data
    environment:
      NOMIFUN_ADMIN_USERNAME: admin
      NOMIFUN_ADMIN_PASSWORD: "change-me-to-something-strong"
      # Set to "true" when NomiFun is behind an HTTPS reverse proxy.
      NOMIFUN_HTTPS: "false"

volumes:
  nomifun-data:

If you prefer to build the image locally from this repo:

docker compose up -d --build
# then open http://<server-ip>:8787  —  pair with the bundled Caddyfile for TLS

# Fast path when ui/dist and target/release/nomifun-web are already built:
bun run docker:prebuilt -- --tag nomifun/nomifun-web:latest --build-missing --sudo

See the Portal installation guide and the local web-server deployment contract for details.

🛠️ Development

bun install        # install dependencies (one-time)
bun run dev        # desktop app development (hot reload)
bun run dev:web    # web host + Vite development
bun run build:ui   # build the SPA
bun run check      # frontend typecheck + i18n + theme + script-registry gate
bun run test       # Rust tests (use test:fast for nextest)

Prefer the scripted entry points over plain cargo/vite — they include build-dir pruning and consistency checks. New to the codebase? Read CONTRIBUTING.md, CONTRIBUTING.zh-CN.md, and docs/contributing/development.md.

📦 Desktop packaging

Each OS has its own command, and a package can only be built on its matching OS — macOS bundles must be signed/notarized on macOS, Windows installers built on Windows, Linux packages on Linux. There is no cross-OS build. All artifacts are collected into dist/desktop/.

Common argument shape for all three:

bun run build:<os> [arch ...] [--signed] [-- <args passed straight to `tauri build`>]

• arch — zero or more architectures. Omit to use the per-OS default below.
• --signed — sign (and, on macOS, notarize). Requires local signing config; see each OS.
• -- … — forwards supported arguments to tauri build (e.g. Windows -- --bundles nsis). macOS product packaging fixes the release profile, selected native target and complete App/DMG output; flags that bypass this contract are rejected. For updater builds, layer on the committed overlay as a file path: bun run build:<os> --config apps/desktop/tauri.updater.conf.json — pass the file, not inline JSON, because Windows PowerShell 5.1 strips the quotes from --config '{...}'.

macOS — build:mac (produces a complete .app and .dmg; Apple Silicon arm64 or Intel x64)

Both architectures use system WKWebView without bundling or downloading a browser runtime. Arch aliases are arm/aarch64/silicon and intel/x64/x86_64; Universal builds are rejected. Intel packages include the verified ONNX Runtime 1.23.2 and its licenses. Use the native package for your architecture. Cross-compilation is not target-machine acceptance. All macOS product commands share the App assembly and signing pipeline. DMG and updater .app.tar.gz are generated from the final App; updater signing also requires the configured Tauri updater private key.

DMGs use ULMO/LZMA compression by default. To produce a compatibility image with UDZO/zlib level 9, run NOMIFUN_MACOS_DMG_FORMAT=UDZO bun run build:mac (the setting also applies to signed builds). ULMO can be mounted on macOS 10.15+; the existing embedded-browser target remains macOS 14+ for both native architectures. Compression changes neither the App's minimum-system declarations nor its browser runtime. For signed release builds with notarization configured, the final App is signed, notarized and stapled before either distribution container is generated; DMG signing and notarization follow container creation.

bun run dev launches a complete development .app and waits for native browser cleanup before a Rust watch restart. build:fast also creates a complete .app and prints its path. Use the App bundle for product testing, including its identity and system permissions.

For a stable installed development signing identity, explicitly set NOMIFUN_MACOS_DEV_SIGN_IDENTITY="Apple Development: Your Name (TEAMID)" for bun run dev or bun run build:fast. The same identity signs the App, including incremental rebuilds; bundle caches are separate for each configured identity. The scripts do not select or create a certificate. With no setting, builds use ad-hoc signing. WK website data is independent of Safari and the retired browser's profiles; users may need to sign into sites once after migration. Existing AgentSession data and application configuration are preserved. See the macOS signing notes.

Developer ID signing reads apps/desktop/signing/.env.signing (gitignored) and requires an installed APPLE_SIGNING_IDENTITY. Configured notarization applies to the final App and DMG. release:mac publishes arm64 artifacts and reads only that build target when generating its updater entry.

Windows — build:win (produces a single NSIS .exe; default arch: the host's, usually x64)

Arch aliases: x64/x86_64, arm64/aarch64/arm. --signed reads the cert thumbprint from WINDOWS_CERTIFICATE_THUMBPRINT (no “notarization” concept on Windows).

Linux — build:linux (produces .deb / .AppImage / .rpm; default arch: the host's)

Arch aliases: x64/x86_64, arm64/aarch64/arm. Linux has no signing/notarization step. ⚠️ Cross-arch (e.g. building arm64 on an x64 host) needs the target's sysroot/toolchain and often fails on the webkit2gtk link — build on the target architecture's machine/container instead.

bun run build builds for the current OS. On macOS it uses the complete native packaging pipeline with arm64 as the default; build:mac intel selects Intel. Windows and Linux retain their existing Tauri build path.

Full script catalog

📖 Documentation

• Product use: NomiFun Portal English docs · 中文产品文档
• Getting started: Installation · Quick start
• Technical architecture: docs/architecture/
• Technical contracts: docs/reference/ · docs/guides/creative-studio.md · docs/guides/web-server-deployment.md
• Development: docs/contributing/ · CONTRIBUTING.md

Product walkthroughs, screenshots, onboarding, and end-user troubleshooting are maintained in Portal. This repository keeps source-level architecture, API/wire contracts, deployment, development, security, and release material.

🗺️ Coming soon

NomiFun is pre-1.0 and built part-time, so there's a lot still in flight. On the horizon: prebuilt installers, inbound issue-tracker / requirement sources, more knowledge connectors (Feishu, and beyond), official desktop binaries — plus a few surprises we're genuinely excited about. Stay tuned. ✨

🤝 Contributing & community

NomiFun very much needs your help to grow — code contributions, community building, and evangelism are all hugely welcome. If you have passion for this project, please reach out and build the NomiFun ecosystem with us.

• Read CONTRIBUTING.md to get set up and learn the check ladder. Simplified Chinese: CONTRIBUTING.zh-CN.md.
• Be excellent to each other — see CODE_OF_CONDUCT.md.
• Found a vulnerability? Follow SECURITY.md.
• Browse open issues for a place to start.

💛 A note from the author

This is a part-time effort with limited bandwidth, and many delightful features are still on the way. If this resonates with you, join in any way you like — a line of code, a suggestion, a reshare all mean a lot.

NomiFun is completely open source, with nothing held back. Individuals and enterprises are free to build on it and use it commercially.

• Forks & commercial use are welcome. They're also at your own risk — the author and contributors assume no liability for downstream use. Apache-2.0 requires no permission from us.
• A friendly heads-up is appreciated, not required. If you fork or commercialize NomiFun, we'd love a note — not as a license condition, simply because knowing the project is valued is the kind of recognition that keeps it going.
• Some features were intentionally left out of the open-source release to keep the local-data promise airtight — without the people and funding to guarantee everyone's data security, removing them was the responsible choice. As time and resources allow, we hope to bring more of them to you.

Thank you for being here. 🙏

🔗 Friendly links

Projects and products we appreciate:

📬 Contact & community

The following contact information is shared across the NomiFun open-source product family. For reproducible bugs and feature requests, GitHub Issues is the preferred channel.

Join the chat groups — scan to join:

⚖️ License

Apache-2.0 © 2025–2026 NomiFun.

See NOTICE for third-party attributions.

_{Built with 💛 for people who want AI on their own terms.}

⬆ Back to top