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

> Set up DeepSeek-Reasonix for local development effortlessly. Follow our complete guide to clone the repo, install dependencies, and build the CLI or desktop app.

- Repository: [YHH/DeepSeek-Reasonix](https://github.com/esengine/DeepSeek-Reasonix)
- Tags: how-to-guide
- Published: 2026-08-10

---

**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`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/desktop/frontend/README.md) for your operating system

### Quick Install via Homebrew (macOS)

```bash
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:

```bash
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`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/control/controller.go)** — The `Controller` struct orchestrates the agent loop, tools, and providers. Both [`cmd/reasonix/main.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/cmd/reasonix/main.go) and [`desktop/main.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/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`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/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`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/cmd/reasonix/main.go) provides subcommand wiring and interactive sessions.

### Step 1: Compile the Binary

```bash
make build

```

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

### Step 2: Run the Setup Wizard

```bash
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

```bash
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

```bash
make wails-install

```

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

### Step 2: Install Front-End Dependencies

```bash
cd desktop
pnpm install

```

### Step 3: Build the Application

```bash
make wails-build

```

Or directly with Wails:

```bash
wails build

```

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

### Step 4: Launch the Desktop UI

```bash
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:

```bash
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`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/control/controller.go), `internal/tool/builtin/`, and `internal/provider/openai/`.

## Key Files for Reference

| File | Purpose |
|------|---------|
| [`cmd/reasonix/main.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/cmd/reasonix/main.go) | CLI entry point and subcommand routing |
| [`internal/control/controller.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/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`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/desktop/main.go) | Wails bootstrap embedding the shared kernel |
| [`desktop/frontend/README.md`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/desktop/frontend/README.md) | Front-end build prerequisites and workflow |
| [`CONTRIBUTING.md`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/CONTRIBUTING.md) | Complete development checklist and environment isolation guidance |

## Configuration Deep-Dive

The [`reasonix.toml`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/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`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/control/controller.go) and related packages.