Command Line (CLI)

TensorSharp.Cli is the console host for local prompts, multimodal experiments, prompt inspection, JSONL batch workflows, the interactive REPL, and built-in benchmarks. The binary lands in TensorSharp.Cli/bin/... after the build.

Quick start in ~30 seconds

Start at the TensorSharp repository root after installing the .NET 10 SDK for your platform. The verified quick start builds the native GGML backend and runs the repository's benchmark-verified gemma-4-E4B-it-Q8_0.gguf (7.48 GiB). The commands take about 30 seconds to copy and run; the model download and the first restore/build take longer and depend on your connection and machine. A native source build also needs Git, network access, CMake, and a working C++ toolchain.

Linux + NVIDIA

TENSORSHARP_GGML_NATIVE_ENABLE_CUDA=ON dotnet build TensorSharp.slnx -c Release -p:TensorSharpSkipMlxNative=true
curl --create-dirs --fail -L "https://huggingface.co/ggml-org/gemma-4-E4B-it-GGUF/resolve/main/gemma-4-E4B-it-Q8_0.gguf?download=true" -o models/gemma-4-E4B-it-Q8_0.gguf
echo "Explain local inference in one paragraph." > prompt.txt
dotnet run --project TensorSharp.Cli -c Release --no-build -- --model models/gemma-4-E4B-it-Q8_0.gguf --input prompt.txt --max-tokens 128 --backend ggml_cuda

Windows PowerShell + NVIDIA

$env:TENSORSHARP_GGML_NATIVE_ENABLE_CUDA = 'ON'
dotnet build TensorSharp.slnx -c Release -p:TensorSharpSkipMlxNative=true
curl.exe --create-dirs --fail -L "https://huggingface.co/ggml-org/gemma-4-E4B-it-GGUF/resolve/main/gemma-4-E4B-it-Q8_0.gguf?download=true" -o models\gemma-4-E4B-it-Q8_0.gguf
Set-Content prompt.txt "Explain local inference in one paragraph."
dotnet run --project TensorSharp.Cli -c Release --no-build -- --model models\gemma-4-E4B-it-Q8_0.gguf --input prompt.txt --max-tokens 128 --backend ggml_cuda

Omit --input and the CLI falls back to its built-in What is 1+1? prompt; for your own one-shot text prompt, save the text to a file and pass --input. --prompt is only the prompt for the image- and video-generation models.

Gemma 4 E4B on other native backends

On Apple Silicon, omit the CUDA environment assignment and use ggml_metal; on a supported Windows/Linux Vulkan GPU, request TENSORSHARP_GGML_NATIVE_ENABLE_VULKAN=ON instead and use ggml_vulkan; ggml_cpu runs the native CPU kernels and needs no GPU. The lower-memory gemma-4-E4B-it-Q4_K_M.gguf is in the same repository. Text needs no mmproj. Add the matching mmproj-gemma-4-E4B-it-Q8_0.gguf with --mmproj only for image, video, or audio input. See Getting Started for full platform syntax.

Examples

Run these source commands from the repository root. Replace the sample paths and choose a native backend that your build supports.

# Text inference (macOS)
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <model.gguf> --input prompt.txt --output result.txt \
    --max-tokens 200 --backend ggml_metal

# Text inference on Windows/Linux + NVIDIA GPU
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <model.gguf> --input prompt.txt --output result.txt \
    --max-tokens 200 --backend ggml_cuda

# Text inference on any Vulkan GPU (AMD / Intel / NVIDIA)
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <model.gguf> --input prompt.txt --output result.txt \
    --max-tokens 200 --backend ggml_vulkan

# Multi-GPU host: list the visible Vulkan devices, then pick one by index
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- --list-gpus
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <model.gguf> --input prompt.txt --max-tokens 200 \
    --backend ggml_vulkan --gpu-device 1

# Interactive turn-by-turn chat (REPL) with KV-cache reuse and slash commands
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <model.gguf> --backend ggml_metal --interactive
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <model.gguf> --backend ggml_metal -i \
    --system "You are a terse assistant." --temperature 0.7 --top-p 0.9 --think

# DSpark block speculative decoding (DeepSeek V4): --model is the FIRST shard of
# the split GGUF, --draft-model the separate DSpark drafter (cuda / ggml_cuda only).
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <DeepSeek-V4-Flash-...-00001-of-00005.gguf> --backend ggml_cuda --layer-split 4 \
    --draft-model <DSpark-drafter.gguf> --input prompt.txt --max-tokens 200 --temperature 0

# GLM 5.x: --model is the FIRST shard; GgufFile finds the rest of the set itself.
# --layer-split 3 places whole layers on 3 local GPUs (e.g. 3x96 GB).
# The advertised 1M context is sized down to the remaining VRAM.
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <GLM-5.2-UD-IQ2_XXS-00001-of-00006.gguf> --backend ggml_cuda --layer-split 3 \
    --input prompt.txt --max-tokens 200 --think

# GLM-5.3 (not Flash) is the same 79-block glm-dsa shape as GLM-5.2 (256 routed
# experts at top-8 plus one shared expert, MLA with the lightning indexer), so it
# loads on the GLM-5.2 path with no new code and no new flag; only the file changes.
# unsloth/GLM-5.3-GGUF keeps one subdirectory per quant, each a multi-shard set
# (UD-Q2_K_XL is seven shards, 236.4 GiB), and it is text only: the repo publishes
# no mmproj at any quant, and an --mmproj on glm-dsa is warned about and ignored.
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <UD-Q2_K_XL/GLM-5.3-UD-Q2_K_XL-00001-of-00007.gguf> --backend ggml_cuda --layer-split 8 \
    --input prompt.txt --max-tokens 200 --think

Multimodal

# Image inference (Gemma 4, Qwen 3.5-family); --mmproj names the projector (see below)
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <model.gguf> --mmproj <mmproj.gguf> --image photo.png \
    --max-tokens 200 --backend ggml_metal

# Video inference (Gemma 4)
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <model.gguf> --mmproj <mmproj.gguf> --video clip.mp4 \
    --max-tokens 200 --backend ggml_metal

# Audio inference (Gemma 4)
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <model.gguf> --mmproj <mmproj.gguf> --audio speech.wav \
    --max-tokens 200 --backend ggml_metal

# PDF document Q&A (--input holds the question; scanned/image-only PDFs
# need a vision model + --mmproj, born-digital PDFs work with any model)
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <model.gguf> --pdf report.pdf --input question.txt \
    --max-tokens 400 --backend ggml_metal

Reasoning, tools & sampling

# Thinking / reasoning mode
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <model.gguf> --input prompt.txt --max-tokens 400 --backend ggml_metal --think

# Tool calling
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <model.gguf> --input prompt.txt --max-tokens 300 --backend ggml_metal \
    --tools tools.json

# With sampling parameters (one-shot runs default to greedy decoding)
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <model.gguf> --input prompt.txt --max-tokens 200 --backend ggml_metal \
    --temperature 0.7 --top-p 0.9 --top-k 40 --repeat-penalty 1.2 --seed 42

Image generation & editing (Qwen-Image-2.1)

# Qwen-Image-2.1: no --image generates an image, --image edits one (repeat it for
# several references). The config downloads the DiT, the dedicated 2.1 VAE and the
# Qwen3-VL-8B text encoder + mmproj. Defaults: 2048x2048, 40 Euler steps, CFG 1.
dotnet run --project TensorSharp.Cli -c Release --no-build -- \
  --config config/qwen-image-2.1.json \
  --prompt 'A small orange cat beside a blue ceramic vase, soft daylight, detailed photograph' \
  --width 2048 --height 2048 --diffusion-steps 40 --cfg 1 \
  --diffusion-seed 42 --output generated.png
dotnet run --project TensorSharp.Cli -c Release --no-build -- \
  --config config/qwen-image-2.1.json \
  --image generated.png \
  --prompt 'Change the blue vase to a red vase. Preserve the cat, lighting and composition.' \
  --width 2048 --height 2048 --diffusion-steps 40 --cfg 1 \
  --diffusion-seed 42 --output edited.png

# A LoRA plug-in: config/lora/ plug-ins download their weights on first use, and a
# step-distilled one brings its sampling recipe (here 6 steps, CFG 1).
dotnet run --project TensorSharp.Cli -c Release --no-build -- \
  --config config/qwen-image-2.1.json \
  --lora config/lora/qwen-image-2.1-viggle-turbo.json \
  --prompt 'A small orange cat beside a blue ceramic vase, soft daylight, detailed photograph' \
  --width 1024 --height 1024 --diffusion-seed 42 --output turbo.png

Local edits: add --mask selection.png to --image photo.png. A matching grayscale mask uses white for edits and black for protected pixels; --mask-mode alpha, --mask-invert, --mask-feather, --mask-crop and --mask-crop-padding control the selection. The result keeps the source dimensions. Full example and mask semantics →

The step-distillation plug-ins in config/lora/ — qwen-image-2.1-viggle-turbo.json, -pruna-8step.json, -pruna-5step.json and -fun-acc-4step.json — replace the 40-step default with their trained 4–8-step recipe, which makes them the main speed lever for image generation. An explicit --diffusion-steps / --cfg still takes precedence, but a step count the recipe has no schedule for is refused. Companions, geometry, the draft settings and the LoRA plug-ins are on Image Generation.

Video generation

MiniMax-H3 denoises the video and a native 32 kHz stereo soundtrack in one packed latent, so the audio comes out of the same forward pass as the picture. It is CFG-distilled, so --cfg 1.0 is required — TensorSharp refuses anything higher — and 4–8 steps is the fast operating point against a 20-step default:

# Text -> H.264 MP4 plus a sidecar WAV. Writes fox.mp4 and fox.wav.
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <minimax_h3_fl2va_pruned-Q4_K.gguf> --backend ggml_metal \
    --prompt "a red fox trotting through falling snow, cinematic" \
    --width 640 --height 384 --video-frames 22 --diffusion-steps 8 --cfg 1.0 \
    --output fox.mp4

# Animate a photo: on the FL2VA checkpoint the image IS the first frame.
# Add --end-image to pin the last frame too (--video-mode fl2v).
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <minimax_h3_fl2va_pruned-Q4_K.gguf> --backend ggml_metal \
    --image portrait.jpg --video-mode i2v \
    --prompt "the person turns toward the camera and smiles" \
    --width 640 --height 384 --video-frames 22 --diffusion-steps 8 --cfg 1.0 \
    --output animated.mp4

# References: keep the subject, build a new scene around it. Ref2VA checkpoint,
# up to nine --ref-image; --ref-video / --ref-audio take clips and soundtracks.
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <minimax_h3_ref2va_pruned-Q4_K.gguf> --backend ggml_metal \
    --ref-image person.jpg --ref-image bottle.png --video-mode ref \
    --prompt "she holds the bottle up to the light on a rooftop at golden hour" \
    --width 640 --height 384 --video-frames 22 --diffusion-steps 20 --cfg 1.0 \
    --output rooftop.mp4

Wan 2.1 / 2.2 generate video alone, and there the checkpoint --model points at decides the wall clock:

# Prompt -> H.264 MP4. The UMT5-XXL text encoder and the video VAE are resolved
# next to the DiT GGUF (or pass --video-text-encoder / --video-vae).
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <Wan2.2-TI2V-5B-Q8_0.gguf> \
    --prompt "A red fox trotting through falling snow, cinematic" \
    --video-frames 81 --fps 24 --output out.mp4 --backend ggml_cuda

# Image -> video: the image becomes the FIRST FRAME and the prompt drives motion
# (Wan 2.2 TI2V-5B and A14B I2V only).
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <Wan2.2-TI2V-5B-Q8_0.gguf> --image first_frame.png \
    --prompt "the camera pushes in as the waves rise" \
    --video-frames 81 --fps 24 --flow-shift 5.0 --output out.mp4 --backend ggml_cuda

# THE FAST LANE: point --model at a step-distilled checkpoint. Nothing else in the
# command changes; the file name alone switches the run to 4 guidance-free passes.
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <Wan2_2-TI2V-5B-Turbo-Q8_0.gguf> --image first_frame.png \
    --prompt "the camera pushes in as the waves rise" \
    --video-frames 121 --fps 24 --output out.mp4 --backend ggml_metal

DiffusionGemma & inspection

# DiffusionGemma text-diffusion generation
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <diffusion-gemma.gguf> --input prompt.txt --backend ggml_metal \
    --max-tokens 256 --diffusion-steps 48 --diffusion-seed 0

# DiffusionGemma with an image (image input only; no audio or video). The Gemma 4
# vision tower comes from an mmproj GGUF or, for diffusiongemma-26B-A4B-it, which
# ships no mmproj, straight from its HuggingFace shard model-00011-of-00011.safetensors.
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <diffusion-gemma.gguf> --mmproj <model-00011-of-00011.safetensors> \
    --image photo.png --input prompt.txt --backend ggml_metal --max-tokens 256

# Inspect the rendered prompt and tokenization without running inference
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <model.gguf> --input prompt.txt --dump-prompt

Batch & benchmarks

# Batch processing (JSONL)
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <model.gguf> --input-jsonl requests.jsonl \
    --output results.txt --backend ggml_metal

# Multi-turn chat simulation with KV-cache reuse (mirrors the web UI behavior)
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <model.gguf> --multi-turn-jsonl chat.jsonl \
    --backend ggml_metal --max-tokens 200

# Throughput benchmark: best-of-N prefill and decode timing
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <model.gguf> --backend ggml_metal \
    --benchmark --bench-prefill 256 --bench-decode 128 --bench-runs 3

The JSONL format is one JSON object per line, with optional sampling fields (temperature, top_k, top_p, min_p, repetition_penalty, repeat_last_n, presence_penalty, frequency_penalty, seed, stop); a field a line leaves out keeps the command-line value, the --repeat-last-n window included:

{"id": "q1", "messages": [{"role": "user", "content": "What is 2+3?"}], "max_tokens": 50}
{"id": "q2", "messages": [{"role": "user", "content": "Write a haiku."}], "max_tokens": 100, "temperature": 0.8}

Configuration file (--config)

Instead of a long command line, pass a JSON file with --config. The server reads the same format. Command-line options always win—when the command line sets a single-valued option itself, that option's entry in the file is dropped before it is resolved (not emitted, its variables not substituted, its download never attempted), so one file can be reused across machines while you override just what differs. Each override prints one [config] --X is set on the command line, so the value from '<file>' is ignored … line to stderr. Repeat --config to layer files (a later file's entry replaces an earlier one's the same way). The repeatable options — --stop, --skills-dir, --skill, --lora, --lora-scale, --lora-config, --image and the --ref-* inputs — keep the file's values and add the command line's after them. Comments and trailing commas are allowed.

# Use the file, but override the backend for this run
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --config config/cli-basic.json --backend ggml_cpu

Keys are the same long option names below (with or without the leading --). A string/number becomes --key value, true becomes the bare switch --key, and an array becomes a repeated flag. false and null emit nothing, so to turn a default-on option off name its negation ("no-continuous-batching": true). lora-scale and lora-config cannot be arrays, and a removed option (such as offload-cpu) is refused as a key. The CLI ignores keys it does not know, so a server-only key such as port has no effect here; repeat-last-n is spelled the same on both hosts and applies to either.

Variables. Define shared values once under "variables" (alias "vars") and reference them with ${name}, or ${name:-fallback} for a default, in any string value (an undefined name falls back to an environment variable of the same name). Declare as many roots as you need.

Auto-download. Any file option can be an object with a local path and one or more urls (or a single url). A relative path resolves against the config file's folder. If path is missing it downloads from the first working URL (mirrors tried in order), saves it there, and reuses it next time; progress prints to stderr, and an optional sha256 verifies a fresh download (an existing file is used as-is). A download entry whose option the command line (or a later file) also sets is dropped before it is resolved, so nothing is fetched for it — --mmproj none skips a configured projector's download.

{
  "variables": { "modelRoot": "C:/models", "hf": "https://huggingface.co" },
  "backend": "ggml_cuda",
  "max-tokens": 256,
  "temperature": 0.7,
  "model": {
    "path": "${modelRoot}/Qwen3.5-9B-Q8_0.gguf",
    "urls": [ "${hf}/unsloth/Qwen3.5-9B-GGUF/resolve/3885219b6810b007914f3a7950a8d1b469d598a5/Qwen3.5-9B-Q8_0.gguf" ],
    "sha256": "809626574d0cb43d4becfa56169980da2bb448f2299270f7be443cb89d0a6ae4"
  }
}

Ready-to-use examples live in the repository's config/ folder (cli-basic.json, server-basic.json, variables.json, auto-download.json, qwen-image-2.1.json) — each uses real, public, ungated URLs, so it works on a fresh machine. See config/README.md for the full reference.

Command-line options

Running the CLI with no arguments — or with --help (also -h, -?, /?) — prints the full parameter reference: every option with its description, default, range, and an example. It exits before any logging or model machinery starts. Documented options are case-insensitive and also accept the --option=value form, as on the server; a switch given a value (--think=on) or a value option with nothing after it is a configuration error (exit code 1). Unknown arguments are ignored, so copy option names carefully—a misspelling may otherwise appear to succeed. (The server is stricter: it refuses to start on an unknown option, and suggests the closest known one when it is within two edits.)

Input / output

Runtime

Sampling

One-shot and batch runs default to greedy decoding: temperature 0, top-k 0, top-p 1.0, min-p 0, penalties off, seed -1 (unlike the server, whose defaults match Ollama) — the defaults listed below. The interactive REPL (-i / --interactive / --chat) samples instead, because greedy chat degenerates into repetition on long answers: temperature 0.8, top-k 40, top-p 0.95, min-p 0.05 and a 64-token penalty window with the repeat penalty left at 1.0, overridden by the GGUF's own general.sampling.* values when it ships them. A flag you pass always wins, in either mode.

Speculative decoding

Off by default. A drafter proposes the next few tokens and the trunk verifies them in one batched forward; every emitted token is still drawn from a trunk row with the run's own sampler, so this is a speed path only — the stream is the one plain decoding would have produced. It engages on --input, --input-jsonl, --multi-turn-jsonl and --interactive, and the flags have to be on the command line before the model loads: --spec is what tells glm-dsa to page its ~3 GiB NextN layer into VRAM (which also leaves less room for the context), and --spec-draft sizes the native graph cache at load. → MTP / NextN · DSpark · docs/speculative_decoding.md

DiffusionGemma, benchmarks & logging

Video generation (MiniMax-H3 · Wan 2.1 / 2.2)

These apply when --model is a video-generation DiT — MiniMax-H3 or Wan. --prompt carries the text, --image supplies the conditioning frame, and --output names the MP4 (default video.mp4; a .png extension writes the frames as PNGs instead). The denoise step count and guidance come from the model's own recipe unless you override them with --diffusion-steps / --cfg.

Of the video families, Wan runs on ggml_cuda, ggml_vulkan, ggml_metal, ggml_cpu, cuda and cpu — it is the one family that rejects --backend mlx outright. Neither Wan nor MiniMax-H3 has a multi-GPU path: unsupported --tp N / --layer-split N requests and distributed groups are refused at load. → MiniMax-H3 measurements · Wan backend timings and cost model

See the full reference, including --test, --test-templates, and chunked-prefill correctness checks, on the API Reference page.

Agent Skills

A skill is a folder holding a SKILL.md plus its scripts, references and assets. The CLI advertises names and descriptions; for a tool-capable model even an explicitly selected skill starts as metadata only, and the model reads its instructions through skills_read when it decides to use it. Families that cannot complete a tool round trip receive selected bodies inline instead. → What the feature does · Over HTTP · From C# · Agentic architecture

# What is registered, where it came from, and any load warnings
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --skills-dir ~/skills --list-skills

# One-shot with a skill selected
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <model.gguf> --backend ggml_metal \
    --skills-dir ~/skills --skill pdf --input prompt.txt --max-tokens 600

# Two skills, no discovery: the model sees exactly these and nothing else
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <model.gguf> --backend ggml_cuda --skills-dir ~/skills \
    --skill pdf --skill xlsx --skills-no-discovery --input prompt.txt

# Interactive, with script execution enabled (your own machine, your own skills)
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <model.gguf> --backend ggml_metal --skills-dir ~/skills \
    --skills-allow-exec -i

The same spellings work in a config file ("skills-dir": ["/srv/skills"]) and on TensorSharp.Server, so one file drives either host. Roots are scanned in precedence order (on the server, its upload directory comes first); when two roots ship the same name the earlier one wins and the other is reported as an error rather than renamed. Inside the REPL, /skills and /skill <name> do the same job for a session — see Interactive REPL commands. Ready-made open-source skills: github.com/anthropics/skills; the full reference is docs/agent_skills.md.

Agentic work and code execution

--code-exec enables a bounded, single-assistant model/tool loop. TensorSharp declares and executes four built-ins — read_file, write_file, shell, and atomic apply_patch — while calls to tools supplied through --tools are returned for the caller to handle. The CLI has no sub-agent runtime — delegation to sub-agents is a server feature, on by default there — and no per-command approval prompt; the startup flags below are the operator's authorization. → Agentic Work

# Persistent interactive workspace; commands stay offline
dotnet run --project TensorSharp.Cli/TensorSharp.Cli.csproj -- \
    --model <model.gguf> --backend ggml_metal --code-exec -i

The CLI keeps one workspace, working directory, permitted exported environment state and installed packages for the chat; skill scripts share it. PATH is deliberately rebuilt for every call, so activating a virtual environment does not persist by mutating PATH. Each command is still a fresh confined process. Linux bubblewrap 0.12+ confines writes, home reads, network and descendants. macOS Seatbelt confines writes/home/network but reports that a deliberately detached child may outlive the request. Windows provides process-tree limits only and therefore refuses in required mode. Generated files are reported with local paths. Code tools are offered to every family that renders tool declarations and parses tool calls, Qwen 3.8 Flash Next (qwen4exp) included; Mistral 3, Hunyuan Dense and DiffusionGemma render none and are not offered them.

Interactive REPL commands

Launch with --interactive / -i. Anything that does not start with / is a user turn; type /help for the list. The prompt header shows the current model, backend, architecture, context length, projector, conversation depth, and pending attachments. Press Ctrl+C while generating to interrupt; at the prompt to exit.

Conversation

Agent Skills

Model & runtime

Sampling (live) & uploads (next turn)