rcli

rcli runs AI models on your own machine: text generation, speech to text, text to speech, and image generation, all through the RunAnywhere SDK.

It is a plain command-line tool with no full-screen interface. Results go to stdout, progress and errors go to stderr, so a redirect keeps the answer and leaves the progress bar on your terminal:

rcli run qwen3 "why is the sky blue" > answer.txt

Install

On macOS and Linux:

curl -fsSL https://raw.githubusercontent.com/RunanywhereAI/RCLI/main/install.sh | bash

That installs Homebrew if you do not have it, adds the tap, and installs rcli. To do the same by hand, note that this repo is its own tap, so tapping it needs the explicit URL form:

brew tap RunanywhereAI/rcli https://github.com/RunanywhereAI/RCLI.git
brew install runanywhereai/rcli/rcli

The name is spelled out because runanywhereai/tap also provides a formula called rcli. If you do not have that tap, plain brew install rcli works too.

That covers an Apple Silicon Mac on macOS 14.5 or later, and x86-64 Linux through Homebrew on Linux. Nothing else to set up: models download when you first ask for one and are kept in ~/.local/share/runanywhere.

Install on Windows

There is no Homebrew on Windows, so the installer downloads the release and unpacks it itself. In PowerShell:

irm https://raw.githubusercontent.com/RunanywhereAI/RCLI/main/install.ps1 | iex

That puts rcli in %LOCALAPPDATA%\Programs\rcli and adds the directory to your user PATH, so open a new terminal before you run it. 64-bit x86 only, and models are kept in %LOCALAPPDATA%\RunAnywhere.

Quick start

rcli list --all                    # everything in the catalog
rcli pull qwen3-0.6b               # download one
rcli run qwen3 "explain mmap"      # ask once and exit
rcli run qwen3                     # interactive prompt, /? for commands
rcli                               # same prompt, no model loaded yet

Models are named by id (qwen3-0.6b) or by the shorter alias (qwen3). rcli run on a model you have not downloaded pulls it first.

Commands

Command	What it does
rcli run [model] [prompt]	Talk to a model. With a prompt it answers and exits; without one you get the interactive prompt. chat is the same command.
rcli list [-a]	Models on this machine. -a / --all lists the whole catalog and marks what is downloaded.
rcli search <query>	Match a query against catalog ids, aliases, and names.
rcli pull <model>	Download a model and wait for it to land.
rcli rm <model>	Delete a downloaded model and report the space freed.
rcli show <model>	Catalog details: engine, kind, format, size, context length, whether it reasons.
rcli stt <file>	Transcribe a 16-bit mono WAV. -m picks the speech model.
rcli tts <text>	Speak text through the speakers, or write a WAV with -o file. -m picks the voice.
rcli imagine <prompt>	Generate an image, draw a preview in the terminal, and print the path. -m picks the model, -q skips the preview. draw is the same command.
rcli bench [model]	Measure tokens per second and time to first token, over one model or every downloaded model that generates text.
rcli engines	Which engines came up and which primitives each one serves. Engines that were compiled in but did not start are listed with the reason.
rcli config [setting] [value]	List settings, read one, or change one.
rcli where	The directory models and generated images live in.

Global flags: --version, -v / --verbose to let the engines log to stderr, and --color auto|always|never.

rcli imagine prints the image path alone on the last line of stdout, so rcli imagine "a red apple" | xargs open works.

The interactive prompt

rcli run <model> with no prompt opens a readline prompt with history and tab completion. Anything that does not start with / goes to the model.

/load <model>	Load a model, downloading it first if needed
/models	What is on this machine
/pull <model>	Download from the catalog
/rm <model>	Delete a downloaded model
/show	Current settings
/set <key> <value>	Change a setting
/image <path>	Ask about a picture. Needs a vision model loaded, and the turn is single-turn
/doc <path>	Put a text file in the context. Text only, truncated at 32000 characters
/imagine <text>	Generate an image
/mic	Record until you press enter, transcribe, and send
/say [text]	Speak the text, or the last answer
/run <cmd>	Run a shell command after you confirm it
/think	Show or hide the model's reasoning
/history	The conversation so far
/clear	Forget the conversation
/bye	Quit

Reasoning tokens go to stderr and the answer goes to stdout, which is why redirecting a one-shot run captures the answer and nothing else.

Settings

rcli config with no arguments lists the settings and their current values:

Setting
accelerator	auto, cpu, gpu, or npu. Advisory; an engine may ignore it
engine	Pin one engine instead of letting priority decide. The allowed values are the engines that actually registered on this machine
context-length	Context window at load time. 0 leaves it to the engine
reasoning	auto, on, or off. auto follows the model
temperature	0 is greedy, 2 is as random as the sampler goes
max-tokens	Longest answer the model may produce, 4096 by default. A model that reasons spends this budget thinking before it answers, so lowering it much can leave no room for the answer itself

Settings live for one process. rcli config temperature 0.2 changes it for that command and nothing else, so to use a setting you either set it in the interactive prompt with /set or accept the default. There is no config file.

Two environment variables: RUNANYWHERE_HOME moves the storage directory, and RCLI_LOG names a file for the engine logs that --verbose would otherwise put on stderr.

Engines

A macOS build links six engines: mlx, llamacpp, neurt, sherpa, cloud, and onnx. Linux and Windows get llamacpp, sherpa, cloud, and onnx. MLX is Metal and NeuRT is the Apple Neural Engine, so neither has anything to link against elsewhere.

Which of those are usable also depends on the machine, so rcli engines is the honest answer for any given install: it lists what registered, and names anything that was compiled in but could not start, with the reason. A model's catalog entry names the engine that runs it, so pulling a model is also how you choose an engine.

Building from source

You need CMake 3.24 or later, Apple Clang for the C++ build, and Xcode for the MLX one. Point the build at a checkout of the SDK:

cmake -B build -DRCLI_SDK_DIR=/path/to/runanywhere-sdks
cmake --build build

Without RCLI_SDK_DIR the SDK is fetched at the tag pinned in cmake/RunAnywhereSDK.cmake, which means a long first build. A sibling checkout reuses what is already built there.

That build produces build/rcli-cxx, with five engines and no MLX. For the binary that ships:

scripts/build-mlx.sh

which produces build/rcli with all six.

The two steps are not interchangeable. MLX inference is Swift, and SwiftPM on the command line cannot compile Metal shaders; mlx-swift documents this in its own README. Only xcodebuild can, so xcodebuild has to own the final link. A binary built without the shaders still links MLX, registers nothing, and reports MLX as unavailable at runtime. scripts/build-mlx.sh harvests the link line CMake wrote and hands it to xcodebuild, which is why cmake --build has to run first.

One more thing that build produces: mlx-swift_Cmlx.bundle, next to the executable. mlx-swift keeps its Metal shaders in a resource bundle rather than inside the binary, so moving rcli somewhere without that directory beside it costs you MLX while the other five engines carry on as if nothing happened. The Homebrew formula installs both into libexec and symlinks the binary for this reason.

Licence

This repo is MIT (see LICENSE), but it links the RunAnywhere SDK, which is not. The SDK is source-available under the RunAnywhere License: free for individuals, for organizations with both less than $1M in total funding and less than $1M in gross annual revenue, and for educational institutions, non-profits, government bodies, and projects under an OSI-approved open source licence. Anyone outside those categories needs a commercial licence, and the contact for that is san@runanywhere.ai.

Read the SDK's licence before you build rcli into a commercial product. The summary above is not the terms.

Built by RunAnywhere, Inc.