No Node.js runtime
The core is built with C11 / C++20 for fast startup and lower memory usage in long-lived terminal sessions.
An AI coding CLI compatible with OpenAI-style APIs and Anthropic APIs. The core is written in C11 / C++20 and ships dstalk_core.dll as a plugin host that exposes a stable C ABI. Nine functional plugins (AI, networking, LSP, sessions, files, tools, and more) compile to standalone DLLs and plug into the CLI, the SDL3 GUI, and any third-party host.
$ build/bin/dstalk_cli.exe config.toml
dstalk v0.1.0 | OpenAI-compatible / Anthropic | /help for help
> Explain the role of dstalk-core
thinking...
AI: dstalk-core is the plugin host. It handles plugin
loading, service registry, the event bus, and
configuration. AI, networking, sessions, LSP, and
file I/O are provided by standalone plugin DLLs;
frontends only deal with input and rendering.
> /file read dstalk-core/include/dstalk/dstalk_host.h
--- dstalk-core/include/dstalk/dstalk_host.h ---
dstalk is positioned alongside tools like Claude Code, OpenCode, and KiloCode, but uses a systems-language implementation and a plugin-host architecture to optimize startup time, runtime footprint, embeddability, and long-running terminal workflows.
The core is built with C11 / C++20 for fast startup and lower memory usage in long-lived terminal sessions.
Public host functions such as dstalk_init and dstalk_service_query, plus 8 service vtables (AI, session, HTTP, file I/O, LSP, and more) make it easy to embed from C/C++, Python, Rust, C#, and Go.
Two AI plugins ship in the box: OpenAI-compatible and Anthropic. Switch between OpenAI-style APIs and Anthropic APIs via ai.provider in config.toml.
dstalk-cli is an ANSI terminal UI; dstalk-gui is a cross-platform SDL3 window. Both share the same plugin host and core capabilities.
The core only handles plugin loading, service registry, event bus, and configuration. AI, networking, LSP, and sessions are independent DLLs you can replace or extend.
Released under GNU GPL v3.0, with example plugins, unit tests, and tutorial docs. Suitable for learning, customization, and local workflow extensions.
dstalk provides an automated toolchain script and a one-command build script. Keep API keys in local config.toml or a secure environment, and never commit them to the repository.
Run setup.bat inside the tools directory to download CMake, Ninja, LLVM/Clang, and Conan2.
Run build.bat to install Conan dependencies, configure CMake, and build with Ninja.
Run build/bin/dstalk_cli.exe with config.toml, or let it use the default config lookup.
# Install toolchain
cd tools
setup.bat
# Return to repo root and build
cd ..
build.bat
# Create config.toml
ai.provider = "ai_openai"
api.base_url = "https://api.openai.com/v1"
api.api_key = "sk-xxxxxxxx"
api.model = "gpt-4o"
# Run CLI
build/bin/dstalk_cli.exe config.toml
dstalk_core.dll acts as a plugin host responsible for plugin loading, service registry, event bus, and configuration. Nine functional plugins — AI, networking, LSP, sessions, files, tools, and more — compile to standalone DLLs, while frontends reach the core only through the C ABI. The GUI is opt-in via the CMake option DSTALK_BUILD_GUI.
┌─────────────────────────────────────────────────────┐
│ Frontends │
│ dstalk-cli (ANSI UI) dstalk-gui (SDL3) │
└───────────────────────┬─────────────────────────────┘
│ C ABI
┌───────────────────────▼─────────────────────────────┐
│ dstalk_core.dll — Plugin Host │
│ Plugin Loader · Service Registry · Event Bus · │
│ Config Manager │
├───────────────┬───────────────┬─────────────────────┤
│ openai (ai) │ anthropic (ai)│ network (http) │
│ lsp (client) │ session │ context │
│ config │ file-io │ tools │
└───────────────┴───────────────┴─────────────────────┘
Boost.JSON · Boost.Asio / Beast · OpenSSL TLS
The following is based on dstalk's CMake files, Conan configuration, and public API header.
| Module | Current technology | Status |
|---|---|---|
| Core library | C11 / C++20, dstalk_core.dll, plugin host, public C ABI | Enabled |
| CLI frontend | ANSI terminal UI using dstalk/dstalk_host.h | Enabled |
| GUI frontend | SDL3 graphical frontend, enabled via CMake option DSTALK_BUILD_GUI | Optional build |
| Plugins | 9 functional plugins (openai · anthropic · network · lsp · session · context · config · file-io · tools), standalone DLLs | Enabled |
| Tests | 10 test targets covering plugin host, event bus, service registry, plugin loader, and AI plugins, integrated with CTest | Enabled |
| Docs | docs/tutorial, docs/reference (commands, plugin-abi), docs/explanation (architecture, plugin-lifecycle, security-logging) | Published |
| Examples | examples/example_plugin shows a plugin template | Available |
| Dependencies | Conan2, boost/1.86.0, openssl/3.4.1 | Configured |
| Build system | CMake 3.21+, Ninja, LLVM/Clang, CMakePresets | Configured |
| License | GNU GPL v3.0 | Confirmed |
In addition to natural-language prompts, dstalk-cli provides commands for files, models, and session management.
| Commands | Description | Example |
|---|---|---|
| /help | Show help | /help |
| /clear | Clear the current conversation context | /clear |
| /model <name> | Switch the current model | /model gpt-4o |
| /file read <path> | Read file content and print it to the terminal | /file read README.md |
| /file write <path> <content> | Write content to a file | /file write note.txt hello |
| /save <path> / /load <path> | Save or restore a session | /save session.json |
dstalk exposes its capabilities through four public headers: dstalk_host.h manages the host lifecycle and plugins, dstalk_services.h defines 8 service vtables, dstalk_lsp.h provides a standalone LSP client, and dstalk_types.h shares message and event types. Frontends call dstalk_service_query() to obtain a service pointer, then invoke capabilities through function pointers.
// Lifecycle
int dstalk_init(const char* config_path);
void dstalk_shutdown(void);
// Plugin management
int dstalk_plugin_load(const char* path);
int dstalk_plugin_unload(int plugin_id);
int dstalk_plugin_list(char** output_json);
void*dstalk_service_query(const char* name, int min_version);
// Event system
int dstalk_event_subscribe(int type, dstalk_event_handler_fn fn, void* ud);
int dstalk_event_emit(int type, const void* data);
void dstalk_event_unsubscribe(int sub_id);
// Config / memory / diagnostics
const char* dstalk_config_get(const char* key);
int dstalk_config_set(const char* key, const char* value);
void*dstalk_alloc(size_t size);
void dstalk_free(void* ptr);
char*dstalk_strdup(const char* s);
void dstalk_set_diag_callback(dstalk_diag_cb cb);
// AI service: dstalk_service_query("ai.openai", 0)
typedef struct {
int (*configure)(const char* provider, const char* base_url,
const char* api_key, const char* model,
int max_tokens, double temperature);
dstalk_chat_result_t (*chat)(const dstalk_message_t* history,
int len, const char* input, const char* tools_json);
dstalk_chat_result_t (*chat_stream)(...);
void (*free_result)(dstalk_chat_result_t* result);
} dstalk_ai_service_t;
// Same pattern: dstalk_session_service_t, dstalk_http_service_t,
// dstalk_file_io_service_t, dstalk_config_service_t,
// dstalk_tools_service_t, dstalk_lsp_service_t
The plugin host, CLI, SDL3 GUI, nine core plugins, tests, and documentation are already in place. Future work focuses on deeper capabilities and ecosystem expansion.
| Phase | Scope | Status |
|---|---|---|
| Skeleton | Project skeleton, CMake/Ninja build, Conan dependencies, DLL exports, frontend main loop | Done |
| Plugin host | Plugin loader, service registry, event bus, configuration; 9 core plugins (openai · anthropic · network · lsp · session · context · config · file-io · tools) | Done |
| Chat capability | HTTPS networking, OpenAI-compatible / Anthropic API adapters, streaming output, multi-turn sessions, file I/O tools | Available |
| GUI frontend | SDL3 graphical window (DSTALK_BUILD_GUI), an optional frontend sharing the same plugin host as the CLI | Optional build |
| Next phase | Deeper LSP integration, third-party plugin SDK, cross-platform distribution, ongoing documentation | Planned |
dstalk is an open project. Developers interested in C/C++, terminal UX, AI API adapters, GUI, documentation, and testing are welcome to participate.
The core, CLI, SDL3 GUI, and nine plugins (AI, networking, LSP, sessions, files, tools, and more) all welcome patches; build scripts and cross-platform compatibility have headroom too.
Use examples/example_plugin and docs/reference/plugin-abi.md as a starting point — register new services through the C ABI to bring your own models, tools, or data sources into dstalk.
docs/tutorial and docs/reference are taking shape; help expand tutorials, command references, plugin-ABI notes, and the coverage of host_api_test / smoke_test.
dstalk is more than a CLI. It is a local AI coding core that can be reused by multiple frontends. dstalk.top will keep tracking project progress, build instructions, and available capabilities.