Kimi Multilingual Desktop 2.1

An unofficial, open-source Windows desktop shell for Kimi Code with Arabic/RTL support and three switchable runtimes:

Runtime	Backend	Internet	Typical use
Original Kimi	Official Kimi account	Yes	Fast cloud models, vision, tools, search, and fetch
CyberStrike 35B	Private bundled llama.cpp	Kimi tools remain online	Practical local GGUF coding and tool use
Kimi K3 · AirLLM	AirLLM 3.1, local 1.56 TB checkpoint	Model offline; Kimi tools remain online	Single-GPU Kimi K3 hardware proof

The desktop shell is C#/.NET WPF with WebView2. Model inference stays in native/CUDA backends; the shell owns process isolation, runtime selection, accessibility, onboarding, and lifecycle recovery.

Project contact: Discord: NN6

Application preview

Fresh captures from Kimi Multilingual Desktop 2.1's privacy-safe showcase. No account name, conversation history, local file path, model weights, or authentication data is shown.

Runtime Center

Highlights

• Compact Windows command bar with 32 px Fluent icon controls and responsive labels.
• Runtime Center keeps full model details available while short labels prevent overlap in the header and composer.
• One-time welcome screen stored outside Kimi Web's changing loopback origin.
• Browser-native Unicode bidi handling for Arabic, Persian, Urdu, Hebrew, mixed RTL/LTR text, code, and emoji.
• Private random loopback ports and per-launch bearer tokens for local runtimes.
• AirLLM K3 is locked to an existing local checkpoint and receives child-only Hugging Face offline flags.
• Original Kimi keeps normal account login, web search, URL fetch, vision, and cloud models.
• High-contrast colors and reduced motion follow Windows settings.

The visual system follows general platform principles—clear hierarchy, restrained toolbars, consistent symbols, and content-first layout—using Windows-native Segoe UI Variable and Segoe Fluent Icons. It does not copy or redistribute Apple SF Symbols, Apple UI assets, or OpenAI/Codex assets.

Requirements

Base app:

• Windows 10 22H2 or Windows 11, x64
• Microsoft Edge WebView2 Runtime (included with current Windows)
• Git for Windows / Git Bash for Kimi Code shell commands
• .NET 10 SDK to build from source

Local GGUF:

• A llama.cpp-compatible GGUF checkpoint
• A supported GPU is strongly recommended
• Sufficient RAM/VRAM for the selected quantization and context

Kimi K3 through AirLLM 3.1:

• Approximately 1.56 TB for the pinned 96-shard checkpoint, plus working/cache space
• NTFS is recommended so AirLLM can hard-link split layers instead of duplicating weights
• NVIDIA GPU with CUDA 12-capable driver
• Python 3.11
• Patience: this is disk-bound, experimental, and not an interactive-speed backend

Validated target: RTX 4090 24 GB, 64 GB RAM, Core i9-14900K, Windows x64. On that machine a clean real load took about 28.5 minutes and a one-token in-app reply took about 14.5 minutes. AirLLM's upstream RTX 6000 Ada result is faster; storage and platform matter heavily.

Install Kimi Multilingual 2.1

1. Install Git for Windows.

2. Install the official Kimi Code CLI:

   irm https://code.kimi.com/kimi-code/install.ps1 | iex
   kimi --version

3. Clone this repository and build:

   git clone https://github.com/112-stack/kimi-multilingual-desktop.git
   Set-Location .\kimi-multilingual-desktop
   powershell -NoProfile -ExecutionPolicy Bypass -File .\build.ps1 `
     -Output "$env:USERPROFILE\Desktop\kimi\desktop-ui-2.1"

4. Point the app at your Kimi CLI if it is not installed under KimiRoot\app\bin\kimi.exe:

   [Environment]::SetEnvironmentVariable(
     'KIMI_CLI_PATH',
     (Get-Command kimi).Source,
     'User')

5. Launch KimiMultilingual.exe. The welcome screen appears once; choose language/appearance and continue.

6. Open Runtime Center from the compact runtime pill and choose Original Kimi, Kimi K3, or a discovered GGUF.

Detailed instructions are in docs/INSTALL.md.

Sign in to Original Kimi

Run:

kimi login

Kimi Code opens the device-authorization page. Approve it in your browser, then relaunch Kimi Multilingual and choose Original Kimi. Tokens remain in Kimi's own user credentials directory and must never be committed to this repository. See docs/KIMI_SIGN_IN.md.

Install open-weight models

No model weights are contained in this repository or its releases.

CyberStrike 35B GGUF

Use the publisher's exact GGUF companion repository:

• huihui-ai/Huihui-CyberStrike-OffSec-35B-abliterated-GGUF

For a 24 GB GPU, the Q4_K file is the practical choice. Place the model and optional mmproj file together under:

KimiRoot\models\CyberStrike-OffSec-35B\
  CyberStrike-OffSec-35B-Q4_K_M.gguf
  CyberStrike-OffSec-35B-mmproj-bf16.gguf

Install a compatible portable llama.cpp runtime at:

KimiRoot\runtime\llama.cpp\bin\llama-server.exe

The app validates the GGUF header, discovers neighboring projectors, launches a private authenticated endpoint, and runs a structured-tool-call probe before showing the workspace.

Kimi K3 (2.8T) through AirLLM 3.1

Read docs/MODELS.md before downloading. The short version:

powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\Install-AirLlmK3.ps1 `
  -KimiRoot "$env:USERPROFILE\Desktop\kimi"
# Review disk requirements, then explicitly request the 1.56 TB download:
powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\Install-AirLlmK3.ps1 `
  -KimiRoot "$env:USERPROFILE\Desktop\kimi" -DownloadCheckpoint

The installer creates an isolated Python environment, installs the pinned AirLLM/CUDA stack, downloads the exact public revision, verifies all 96 shards, and applies the documented Windows compatibility patch. The desktop process later sets HF_HUB_OFFLINE=1, TRANSFORMERS_OFFLINE=1, HF_DATASETS_OFFLINE=1, and telemetry disablement only for the AirLLM child. Kimi's own internet tools are not disabled.

Build and test

dotnet build .\KimiMultilingual.csproj -c Release
dotnet run --project .\tests\UpdateSmoke\UpdateSmoke.csproj -c Release
.\airllm-v3.1.0\.venv\Scripts\python.exe .\airllm-v3.1.0\server\test_openai_server.py

The smoke suite covers runtime isolation, exact model metadata, compact label contracts, fixed project contact, GGUF discovery/projector pairing, clean/resumable AirLLM layer-cache setup, config migration, first-run persistence, bidi route handling, and install locking.

Real model QA is intentionally separate because it can occupy the GPU for hours. Never run K3 and a full-GPU GGUF server concurrently.

Privacy and security

• Local inference binds to 127.0.0.1 on a random port.
• A random per-launch API token is passed only to the app-owned child process.
• The app stops only processes it started.
• AirLLM refuses model repository IDs at runtime; the K3 checkpoint must already be a local directory.
• User credentials, sessions, logs, models, caches, build output, and tokens are excluded by .gitignore.
• Do not use --dangerous-bypass-auth for Kimi Web.

See SECURITY.md for reporting and deployment guidance.

Project layout

Assets/                    WPF resources and bidi bootstrap
Services/                  Runtime, Kimi, update, settings, and process hosts
airllm-v3.1.0/server/      OpenAI-compatible AirLLM adapter and contract tests
scripts/                   Reproducible installation helpers
tests/UpdateSmoke/         Fast .NET smoke tests
docs/                      Install, model, sign-in, and architecture guides

License and trademarks

The project is licensed under Apache-2.0. Third-party projects and model weights retain their own licenses; review THIRD_PARTY_NOTICES.md and each model card before use.

Kimi, Kimi Code, Kimi K3, AirLLM, Hugging Face, Apple, OpenAI, Codex, Windows, and Discord are trademarks of their respective owners. This community project is not endorsed by Moonshot AI, AirLLM's maintainers, Apple, OpenAI, Microsoft, Hugging Face, or Discord.