How to Set Up DeepSeek-Reasonix for Local Development: A Complete Guide

You can set up DeepSeek-Reasonix locally by cloning the repository, installing Go 1.25+ (plus Node 24+ and Wails for desktop), and running make build for the CLI or make wails-build for the desktop app.

DeepSeek-Reasonix is a Go-based autonomous coding agent that runs as a CLI/TUI, desktop application, or VS Code extension. Its modular internal/control kernel powers all interfaces, making it straightforward to develop different components independently using isolated home directories. This guide walks through the complete setup process using exact commands and file paths from the official source.

Prerequisites

DeepSeek-Reasonix requires different dependencies depending on which components you plan to build.

Core Requirements (CLI and Desktop)

• Go 1.25+ — Required for compiling the kernel and all entry points
• Node 24+ and pnpm 10 — Used exclusively for the desktop front-end
• Wails CLI — Must match the pinned version in .wails-version for desktop builds
• Platform-specific webview libraries — See desktop/frontend/README.md for your operating system

Quick Install via Homebrew (macOS)

brew install go node pnpm wails

Linux and Windows users should follow the Go, Node, and Wails official installation guides, then verify versions against the repository's pinned requirements.

Clone the Repository

Start with a fresh clone of the main branch:

git clone https://github.com/esengine/DeepSeek-Reasonix.git
cd DeepSeek-Reasonix

The repository structure separates concerns cleanly: cmd/reasonix/ for the CLI, desktop/ for the Wails-based GUI, and internal/ for the shared kernel.

Understanding the Architecture

Before building, it helps to understand how the components interact:

• internal/control/controller.go — The Controller struct orchestrates the agent loop, tools, and providers. Both cmd/reasonix/main.go and desktop/main.go import and initialize this same controller
• internal/tool/builtin/* — Built-in tools like bash and read_file register themselves via tool.RegisterBuiltin during package init
• internal/provider/openai/* — OpenAI-compatible backends configured through reasonix.toml
• Stateless kernel design — The controller uses only a configurable home directory (REASONIX_HOME), enabling safe parallel development of CLI and desktop without conflicts

Build Path A: CLI and TUI

The CLI entry point at cmd/reasonix/main.go provides subcommand wiring and interactive sessions.

Step 1: Compile the Binary

make build

This produces bin/reasonix (or bin/reasonix.exe on Windows).

Step 2: Run the Setup Wizard

REASONIX_HOME=/tmp/reasonix-dev ./bin/reasonix setup

The wizard interactively prompts for a provider and model, writing configuration to $REASONIX_HOME/reasonix.toml.

Step 3: Start an Interactive Session

REASONIX_HOME=/tmp/reasonix-dev ./bin/reasonix

Using a custom REASONIX_HOME isolates development data from any stable release installation.

Build Path B: Desktop Application

The desktop module in desktop/ embeds a React/Vite web-view through Wails, reusing the same internal/control.Controller kernel with added native window handling.

Step 1: Install Wails

make wails-install

This installs the exact Wails version specified in .wails-version, preventing version mismatch issues.

Step 2: Install Front-End Dependencies

cd desktop
pnpm install

Step 3: Build the Application

make wails-build

Or directly with Wails:

wails build

Output appears in dist/Reasonix (macOS .app, Windows .exe, or Linux binary).

Step 4: Launch the Desktop UI

REASONIX_HOME=/tmp/reasonix-desktop ./dist/Reasonix

Again, a dedicated REASONIX_HOME keeps development state separate from other builds.

Running Tests

Verify your build with the test suites:

make test                    # Full Go test suite for kernel and CLI

make desktop-test            # Desktop-specific integration tests

make desktop-test-short      # Faster subset for quick validation

Tests exercise the Controller logic, built-in tool registration, and provider configurations found in internal/control/controller.go, internal/tool/builtin/, and internal/provider/openai/.

Key Files for Reference

File	Purpose
cmd/reasonix/main.go	CLI entry point and subcommand routing
internal/control/controller.go	Core Controller used by both CLI and desktop
internal/tool/builtin/*	Built-in tool implementations with auto-registration
internal/provider/openai/*	OpenAI-compatible provider for default setup
desktop/main.go	Wails bootstrap embedding the shared kernel
desktop/frontend/README.md	Front-end build prerequisites and workflow
CONTRIBUTING.md	Complete development checklist and environment isolation guidance

Configuration Deep-Dive

The reasonix.toml file controls provider selection, model parameters, and tool permissions. The setup wizard generates this automatically, but you can edit it directly in your REASONIX_HOME directory. Provider implementations in internal/provider/openai/ parse this configuration and handle API communication.

Summary

• Clone with git clone https://github.com/esengine/DeepSeek-Reasonix.git
• Install Go 1.25+, Node 24+, pnpm 10, and pinned Wails CLI
• Build CLI with make build and run ./bin/reasonix setup
• Build Desktop with make wails-install, pnpm install, and make wails-build
• Isolate environments using REASONIX_HOME for parallel development
• Test everything with make test and make desktop-test

Frequently Asked Questions

Do I need to build both CLI and desktop for local development?

No. The shared internal/control kernel means you can develop either interface independently. The CLI builds faster and is sufficient for testing core agent logic, while the desktop requires additional Node and Wails setup for UI work.

Why does the desktop need Node and pnpm if it's a Go project?

The desktop uses Wails to embed a React/Vite front-end in a native window. The desktop/ directory is a separate Go module that compiles the web assets into the final binary. The kernel remains pure Go and is imported as a dependency.

How do I switch between development and stable releases?

Set distinct REASONIX_HOME paths. The controller stores all state—configuration, conversation history, and tool outputs—exclusively in this directory. Running with REASONIX_HOME=/tmp/reasonix-dev guarantees isolation from ~/.reasonix used by stable installations.

What Go version is strictly required?

Go 1.25 or later. The codebase uses language features and standard library APIs introduced in that release. Earlier versions will fail to compile internal/control/controller.go and related packages.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}