Repository navigation
Releases
LexiSuite Testing Image 13
LexiSuite
LexiSuite is a complete, self-contained platform for running AI models on your own hardware, written in Rust from
the kernel up. One codebase contains the operating system (LexiOS), a kernel designed around inference
(LexiKernel), the inference engine that runs the models on the GPU (LexiEngine), and the browser control panel that
operates all of it (LexiPanel), together with its own virtual machine monitor, training and quantization tools. It
boots from one USB image. Nothing in it depends on a cloud service.
It is not a wrapper around llama.cpp, Ollama, vLLM or PyTorch. The inference engine, its GPU kernels, the scheduler,
the samplers and the HTTP APIs are original Rust and GLSL/CUDA code, and on the cards it is tuned for it is measured
against the newest llama.cpp release on every change (see The numbers).
It is developed every day by its author as their own primary AI platform. The test counts and the benchmark dates in
this file are all from the current week.
Current version: 92ff3f3, 11/15/2026. The USB image, the source, this page, the wiki and
lexipanel.com all describe this one version.
Download: the development USB image 92ff3f3 is on the download page at
lexipanel.com/download and on Hugging Face at
huggingface.co/Wa1k3r/LexiSuite. It passed its virtual-machine qualification, and its LexiKernel is the one that boots a Ryzen desktop (MSI X570, Ryzen 9 5900X). Earlier images are at
github.com/W61k3r/LexiSuite-Releases/releases; the user
guide is the wiki. Flash the image to a USB stick, boot it, and
open the address shown on the screen.
OS / Kernel / Engine / Panel. All Rust.
What it is •
Why nothing else is like it •
The numbers •
What it does •
Architecture •
Performance •
Models •
Quick start •
API •
Hardware •
Security •
Status •
License
What it is
LexiSuite is four products built to work as one system:
| Component | What it is | Where |
|---|---|---|
| LexiEngine | Native Rust inference server: GGUF models on Vulkan, CUDA and CPU, with OpenAI-compatible and Anthropic Messages-compatible HTTP APIs | lexipanel-rs/engine |
| LexiPanel | Authenticated browser control plane for models, instances, GPUs, storage, fleets, training and virtual machines: 1,162 features, 58 guided tasks | lexipanel-rs |
| LexiOS | Rust-first appliance OS that boots straight into the Panel (Linux 7.4-rc2 in the newest image): init, network, firewall, storage, setup, updates | lexios |
| LexiKernel | Rust kernel with a Linux ABI, built around inference workloads; has booted real hardware and served the Panel from it | lexios/lexikernel |
Who it is for: anyone who wants to run large language models on hardware they own (one desktop GPU up to a small
fleet) and wants one system to do it, instead of assembling and maintaining a dozen separate projects.
What you get, concretely:
- Plug in a USB stick, boot, open a browser. The machine finds its GPUs, checks the engine can use them, and
shows the Panel on the network. Download a model from the Panel and chat with it or point any OpenAI or Anthropic
client at it. - An engine that beats llama.cpp 1.0.0 on the models it is tuned for, and says where it does not. Measured on
11/15/2026 on a Radeon RX 7900 XTX against llama.cpp 1.0.0 with the same settings: a 27B Qwen model at a
262,144-token context generates 19% to 26% faster and reads prompts 26% to 36% faster up to 33,000 tokens, and it
answers 134,000-token and 262,000-token prompts where llama.cpp 1.0.0 returns nothing. A 32-turn agentic coding
session on the same model finishes in 194 s against 309 s. Gemma 4 31B and E4B now generate faster than
llama.cpp 1.0.0 as well. - Everything else an AI box needs, in the same GUI: model library and downloads, per-GPU instances, benchmarks
against a reference engine, automatic parameter optimization, quantization to fit a card, LoRA training, typed
decisions with probabilities, agents with per-tool permissions, users and API keys, backups, updates, a fleet view,
virtual machines with GPU passthrough, a file manager and a terminal. - Security that is tested, not asserted: about 4,200 of the 16,518 tests exist to prove that something is refused.
Why nothing else is like it
Local AI today is an archipelago: an inference server from one project, a chat front end from another, a general
Linux distribution under them, a hypervisor from a fourth, quantization and training scripts from a fifth, and
monitoring bolted on. Each is an island, and the person running the box is the ferry.
LexiSuite is self-contained like an island, but it is the size of a continent: every one of those layers is in one
Rust codebase, built to the same rules, tested together and shipped as one image.
| Layer | What people normally assemble | In LexiSuite |
|---|---|---|
| Kernel | Linux, general purpose | LexiKernel: Rust, Linux ABI, inference-first scheduling, VRAM admission, IOMMU required. Linux 7.4 is the other boot entry on the same stick |
| Operating system | Ubuntu, Debian, Proxmox, a NAS distribution | LexiOS: boots into the Panel; firewall verified by PID 1; signed updates with rollback; self-test on every boot |
| Inference engine | llama.cpp, Ollama, vLLM, LM Studio | LexiEngine: original Rust engine with its own Vulkan and CUDA kernels. Upstream llama.cpp can also be installed from the Panel and run beside it |
| APIs | Whatever the server offers | OpenAI Chat, Completions and Responses, Anthropic Messages, embeddings, rerank, image generation, and typed decisions (/v1/decide) |
| Control panel and chat | Open WebUI, LM Studio, a dashboard, SSH | LexiPanel: one authenticated GUI for every operation on the box, including chat |
| Tuning | Hand-edited flags and forum posts | Benchmarks, an optimizer that keeps measured winners, GPU power caps, Fit (requantize a model to a card) |
| Training | Separate Python environments | LexiML: LoRA fine-tuning and gate training from the Panel or lexi-train |
| Virtual machines | QEMU, Proxmox | lexi-vmm: a safe-Rust VM monitor on KVM with virtio devices, VFIO passthrough and snapshots |
| Diagnostics | Logs scattered across tools | Live hardware view, crash evidence kept across restarts, one-click debug kits |
| Fleet | Ansible, scripts | Signed, opt-in remote actions across boxes from one Panel |
What follows from owning every layer:
- Problems are fixed where they are, not worked around. When the engine needed the GPU's memory accounting to be
exact at a 240,000-token context, the allocator, the admission rule and the kernel interface were all in reach. - One rule set. The same permission function decides every page, form and guided-task step; the same fail-closed
policy applies from the boot loader to an HTTP route. - One language. 1.95 million lines of Rust in 340 crates;
unsafeis confined to drivers, hardware paths and
FFI boundaries. - It can be reasoned about by one person, or one AI. The whole system is in one repository with one build.
Comparisons in one line each:
- llama.cpp / Ollama / LM Studio are inference engines or desktop apps. LexiSuite includes an engine of that
class and also the OS, kernel, control plane, VM host and tooling around it. - vLLM / TGI are datacenter serving stacks for Python environments. LexiSuite targets owned desktop and
workstation GPUs and has no Python in the serving path. - Open WebUI and similar are front ends for someone else's engine. LexiPanel operates the whole machine.
- Proxmox / TrueNAS are appliance operating systems for VMs and storage. LexiOS is that kind of appliance for
inference, with its own engine.
The numbers
All measured on 11/15/2026 on one Radeon RX 7900 XTX (24 GB, capped at 291 W) in an Intel i7-9700 desktop,
nothing else running, on version 92ff3f3, against llama.cpp 1.0.0 (build b12359, Vulkan, flash attention) run
the same night with identical settings. Conditions are in Performance.
| What | LexiEngine | llama.cpp 1.0.0 |
|---|---|---|
| Qwen3.8 27B Q4_K_M, 262,144-token context, 4-bit K/V cache, draft-head speculation: generation, short prompt | 76.9 tok/s | 64.1 tok/s |
| Same, generation after a 3,600-token prompt | 71.5 tok/s | 56.6 tok/s |
| Same, generation after a 33,000-token prompt | 69.8 tok/s | 55.9 tok/s |
| Same, generation after a 134,000-token prompt | 50.2 tok/s | no result |
| Same, generation after a 262,000-token prompt (the full window) | 39.8 tok/s | not run (no result at 134,000) |
| Same, p... |
LexiSuite Testing Image 12
LexiSuite
LexiSuite is a complete, self-contained platform for running AI models on your own hardware, written in Rust from
the kernel up. One codebase contains the operating system (LexiOS), a kernel designed around inference
(LexiKernel), the inference engine that runs the models on the GPU (LexiEngine), and the browser control panel that
operates all of it (LexiPanel), together with its own virtual machine monitor, training and quantization tools. It
boots from one USB image. Nothing in it depends on a cloud service.
It is not a wrapper around llama.cpp, Ollama, vLLM or PyTorch. The inference engine, its GPU kernels, the scheduler,
the samplers and the HTTP APIs are original Rust and GLSL/CUDA code, and on the cards it is tuned for it is measured
against the newest llama.cpp release on every change (see The numbers).
It is developed every day by its author as their own primary AI platform. The test counts and the benchmark dates in
this file are all from the current week.
Current version: 14d173b, 11/14/2026. The USB image, the source, this page, the wiki and
lexipanel.com all describe this one version.
Download: the development USB image 14d173b is on the download page at
lexipanel.com/download and on Hugging Face at
huggingface.co/Wa1k3r/LexiSuite. It passed its virtual-machine qualification, and its LexiKernel is the one that boots a Ryzen desktop (MSI X570, Ryzen 9 5900X). Earlier images are at
github.com/W61k3r/LexiSuite-Releases/releases; the user
guide is the wiki. Flash the image to a USB stick, boot it, and
open the address shown on the screen.
OS / Kernel / Engine / Panel. All Rust.
What it is •
Why nothing else is like it •
The numbers •
What it does •
Architecture •
Performance •
Models •
Quick start •
API •
Hardware •
Security •
Status •
License
What it is
LexiSuite is four products built to work as one system:
| Component | What it is | Where |
|---|---|---|
| LexiEngine | Native Rust inference server: GGUF models on Vulkan, CUDA and CPU, with OpenAI-compatible and Anthropic Messages-compatible HTTP APIs | lexipanel-rs/engine |
| LexiPanel | Authenticated browser control plane for models, instances, GPUs, storage, fleets, training and virtual machines: 1,162 features, 58 guided tasks | lexipanel-rs |
| LexiOS | Rust-first appliance OS that boots straight into the Panel (Linux 7.4-rc2 in the newest image): init, network, firewall, storage, setup, updates | lexios |
| LexiKernel | Rust kernel with a Linux ABI, built around inference workloads; has booted real hardware and served the Panel from it | lexios/lexikernel |
Who it is for: anyone who wants to run large language models on hardware they own (one desktop GPU up to a small
fleet) and wants one system to do it, instead of assembling and maintaining a dozen separate projects.
What you get, concretely:
- Plug in a USB stick, boot, open a browser. The machine finds its GPUs, checks the engine can use them, and
shows the Panel on the network. Download a model from the Panel and chat with it or point any OpenAI or Anthropic
client at it. - An engine that beats llama.cpp 1.0.0 on the Qwen family, and says where it does not. Measured on 11/13/2026
on a Radeon RX 7900 XTX against llama.cpp 1.0.0 (released the same day) with the same settings: a 27B Qwen model
at a 262,144-token context generates 17% to 25% faster and reads prompts 26% to 37% faster up to 33,000 tokens,
and it answers 134,000-token and 262,000-token prompts where llama.cpp 1.0.0 returns nothing (its Vulkan device was lost
on the 134,000-token prompt). A 32-turn
agentic coding session on the same model finishes in 193 s against 305 s. - Everything else an AI box needs, in the same GUI: model library and downloads, per-GPU instances, benchmarks
against a reference engine, automatic parameter optimization, quantization to fit a card, LoRA training, typed
decisions with probabilities, agents with per-tool permissions, users and API keys, backups, updates, a fleet view,
virtual machines with GPU passthrough, a file manager and a terminal. - Security that is tested, not asserted: about 4,200 of the 16,457 tests exist to prove that something is refused.
Why nothing else is like it
Local AI today is an archipelago: an inference server from one project, a chat front end from another, a general
Linux distribution under them, a hypervisor from a fourth, quantization and training scripts from a fifth, and
monitoring bolted on. Each is an island, and the person running the box is the ferry.
LexiSuite is self-contained like an island, but it is the size of a continent: every one of those layers is in one
Rust codebase, built to the same rules, tested together and shipped as one image.
| Layer | What people normally assemble | In LexiSuite |
|---|---|---|
| Kernel | Linux, general purpose | LexiKernel: Rust, Linux ABI, inference-first scheduling, VRAM admission, IOMMU required. Linux 7.4 is the other boot entry on the same stick |
| Operating system | Ubuntu, Debian, Proxmox, a NAS distribution | LexiOS: boots into the Panel; firewall verified by PID 1; signed updates with rollback; self-test on every boot |
| Inference engine | llama.cpp, Ollama, vLLM, LM Studio | LexiEngine: original Rust engine with its own Vulkan and CUDA kernels. Upstream llama.cpp can also be installed from the Panel and run beside it |
| APIs | Whatever the server offers | OpenAI Chat, Completions and Responses, Anthropic Messages, embeddings, rerank, image generation, and typed decisions (/v1/decide) |
| Control panel and chat | Open WebUI, LM Studio, a dashboard, SSH | LexiPanel: one authenticated GUI for every operation on the box, including chat |
| Tuning | Hand-edited flags and forum posts | Benchmarks, an optimizer that keeps measured winners, GPU power caps, Fit (requantize a model to a card) |
| Training | Separate Python environments | LexiML: LoRA fine-tuning and gate training from the Panel or lexi-train |
| Virtual machines | QEMU, Proxmox | lexi-vmm: a safe-Rust VM monitor on KVM with virtio devices, VFIO passthrough and snapshots |
| Diagnostics | Logs scattered across tools | Live hardware view, crash evidence kept across restarts, one-click debug kits |
| Fleet | Ansible, scripts | Signed, opt-in remote actions across boxes from one Panel |
What follows from owning every layer:
- Problems are fixed where they are, not worked around. When the engine needed the GPU's memory accounting to be
exact at a 240,000-token context, the allocator, the admission rule and the kernel interface were all in reach. - One rule set. The same permission function decides every page, form and guided-task step; the same fail-closed
policy applies from the boot loader to an HTTP route. - One language. 1.93 million lines of Rust in 340 crates;
unsafeis confined to drivers, hardware paths and
FFI boundaries. - It can be reasoned about by one person, or one AI. The whole system is in one repository with one build.
Comparisons in one line each:
- llama.cpp / Ollama / LM Studio are inference engines or desktop apps. LexiSuite includes an engine of that
class and also the OS, kernel, control plane, VM host and tooling around it. - vLLM / TGI are datacenter serving stacks for Python environments. LexiSuite targets owned desktop and
workstation GPUs and has no Python in the serving path. - Open WebUI and similar are front ends for someone else's engine. LexiPanel operates the whole machine.
- Proxmox / TrueNAS are appliance operating systems for VMs and storage. LexiOS is that kind of appliance for
inference, with its own engine.
The numbers
Measured on 11/13 and 11/14/2026 on one Radeon RX 7900 XTX (24 GB, capped at 291 W) in an Intel i7-9700 desktop,
nothing else running, against llama.cpp 1.0.0 (build b12359, Vulkan, flash attention) with identical
settings. The Qwen rows were measured on 11/13 on version afaf544, whose Qwen path is unchanged in 14d173b (the first four rows of the 27B table, measured again on 14d173b, came within 2%); the Gemma rows on 11/14 on 14d173b. Conditions are in Performance.
| What | LexiEngine | llama.cpp 1.0.0 |
|---|---|---|
| Qwen3.8 27B Q4_K_M, 262,144-token context, 4-bit K/V cache, draft-head speculation: generation, short prompt | 76.8 tok/s | 65.3 tok/s |
| Same, generation after a 3,600-token prompt | 71.4 tok/s | 57.0 tok/s |
| Same, generation after a 33,000-token prompt | 70.0 tok/s | 55.8 tok/s |
| Same, generation ... |
LexiSuite Testing Image 11
LexiSuite
LexiSuite is a complete, self-contained platform for running AI models on your own hardware, written in Rust from
the kernel up. One codebase contains the operating system (LexiOS), a kernel designed around inference
(LexiKernel), the inference engine that runs the models on the GPU (LexiEngine), and the browser control panel that
operates all of it (LexiPanel), together with its own virtual machine monitor, training and quantization tools. It
boots from one USB image. Nothing in it depends on a cloud service.
It is not a wrapper around llama.cpp, Ollama, vLLM or PyTorch. The inference engine, its GPU kernels, the scheduler,
the samplers and the HTTP APIs are original Rust and GLSL/CUDA code, and on the cards it is tuned for it is measured
against the newest llama.cpp release on every change (see The numbers).
It is developed every day by its author as their own primary AI platform. The test counts and the benchmark dates in
this file are all from the current week.
Current version: afaf544, 11/13/2026. The USB image, the source, this page, the wiki and
lexipanel.com all describe this one version.
Download: the development USB image afaf544 is on the download page at
lexipanel.com/download and on Hugging Face at
huggingface.co/Wa1k3r/LexiSuite. It passed its virtual-machine qualification, and its LexiKernel is the one that boots a Ryzen desktop (MSI X570, Ryzen 9 5900X). Earlier images are at
github.com/W61k3r/LexiSuite-Releases/releases; the user
guide is the wiki. Flash the image to a USB stick, boot it, and
open the address shown on the screen.
OS / Kernel / Engine / Panel. All Rust.
What it is •
Why nothing else is like it •
The numbers •
What it does •
Architecture •
Performance •
Models •
Quick start •
API •
Hardware •
Security •
Status •
License
What it is
LexiSuite is four products built to work as one system:
| Component | What it is | Where |
|---|---|---|
| LexiEngine | Native Rust inference server: GGUF models on Vulkan, CUDA and CPU, with OpenAI-compatible and Anthropic Messages-compatible HTTP APIs | lexipanel-rs/engine |
| LexiPanel | Authenticated browser control plane for models, instances, GPUs, storage, fleets, training and virtual machines: 1,162 features, 58 guided tasks | lexipanel-rs |
| LexiOS | Rust-first appliance OS that boots straight into the Panel (Linux 7.4-rc2 in the newest image): init, network, firewall, storage, setup, updates | lexios |
| LexiKernel | Rust kernel with a Linux ABI, built around inference workloads; has booted real hardware and served the Panel from it | lexios/lexikernel |
Who it is for: anyone who wants to run large language models on hardware they own (one desktop GPU up to a small
fleet) and wants one system to do it, instead of assembling and maintaining a dozen separate projects.
What you get, concretely:
- Plug in a USB stick, boot, open a browser. The machine finds its GPUs, checks the engine can use them, and
shows the Panel on the network. Download a model from the Panel and chat with it or point any OpenAI or Anthropic
client at it. - An engine that beats llama.cpp 1.0.0 on the Qwen family, and says where it does not. Measured on 11/13/2026
on a Radeon RX 7900 XTX against llama.cpp 1.0.0 (released the same day) with the same settings: a 27B Qwen model
at a 262,144-token context generates 17% to 25% faster and reads prompts 26% to 37% faster up to 33,000 tokens,
and it answers 134,000-token and 262,000-token prompts where llama.cpp 1.0.0 returns nothing (its Vulkan device was lost
on the 134,000-token prompt). A 32-turn
agentic coding session on the same model finishes in 193 s against 305 s. - Everything else an AI box needs, in the same GUI: model library and downloads, per-GPU instances, benchmarks
against a reference engine, automatic parameter optimization, quantization to fit a card, LoRA training, typed
decisions with probabilities, agents with per-tool permissions, users and API keys, backups, updates, a fleet view,
virtual machines with GPU passthrough, a file manager and a terminal. - Security that is tested, not asserted: about 4,200 of the 16,418 tests exist to prove that something is refused.
Why nothing else is like it
Local AI today is an archipelago: an inference server from one project, a chat front end from another, a general
Linux distribution under them, a hypervisor from a fourth, quantization and training scripts from a fifth, and
monitoring bolted on. Each is an island, and the person running the box is the ferry.
LexiSuite is self-contained like an island, but it is the size of a continent: every one of those layers is in one
Rust codebase, built to the same rules, tested together and shipped as one image.
| Layer | What people normally assemble | In LexiSuite |
|---|---|---|
| Kernel | Linux, general purpose | LexiKernel: Rust, Linux ABI, inference-first scheduling, VRAM admission, IOMMU required. Linux 7.4 is the other boot entry on the same stick |
| Operating system | Ubuntu, Debian, Proxmox, a NAS distribution | LexiOS: boots into the Panel; firewall verified by PID 1; signed updates with rollback; self-test on every boot |
| Inference engine | llama.cpp, Ollama, vLLM, LM Studio | LexiEngine: original Rust engine with its own Vulkan and CUDA kernels. Upstream llama.cpp can also be installed from the Panel and run beside it |
| APIs | Whatever the server offers | OpenAI Chat, Completions and Responses, Anthropic Messages, embeddings, rerank, image generation, and typed decisions (/v1/decide) |
| Control panel and chat | Open WebUI, LM Studio, a dashboard, SSH | LexiPanel: one authenticated GUI for every operation on the box, including chat |
| Tuning | Hand-edited flags and forum posts | Benchmarks, an optimizer that keeps measured winners, GPU power caps, Fit (requantize a model to a card) |
| Training | Separate Python environments | LexiML: LoRA fine-tuning and gate training from the Panel or lexi-train |
| Virtual machines | QEMU, Proxmox | lexi-vmm: a safe-Rust VM monitor on KVM with virtio devices, VFIO passthrough and snapshots |
| Diagnostics | Logs scattered across tools | Live hardware view, crash evidence kept across restarts, one-click debug kits |
| Fleet | Ansible, scripts | Signed, opt-in remote actions across boxes from one Panel |
What follows from owning every layer:
- Problems are fixed where they are, not worked around. When the engine needed the GPU's memory accounting to be
exact at a 240,000-token context, the allocator, the admission rule and the kernel interface were all in reach. - One rule set. The same permission function decides every page, form and guided-task step; the same fail-closed
policy applies from the boot loader to an HTTP route. - One language. 1.93 million lines of Rust in 340 crates;
unsafeis confined to drivers, hardware paths and
FFI boundaries. - It can be reasoned about by one person, or one AI. The whole system is in one repository with one build.
Comparisons in one line each:
- llama.cpp / Ollama / LM Studio are inference engines or desktop apps. LexiSuite includes an engine of that
class and also the OS, kernel, control plane, VM host and tooling around it. - vLLM / TGI are datacenter serving stacks for Python environments. LexiSuite targets owned desktop and
workstation GPUs and has no Python in the serving path. - Open WebUI and similar are front ends for someone else's engine. LexiPanel operates the whole machine.
- Proxmox / TrueNAS are appliance operating systems for VMs and storage. LexiOS is that kind of appliance for
inference, with its own engine.
The numbers
All measured on 11/13/2026 on one Radeon RX 7900 XTX (24 GB, capped at 291 W) in an Intel i7-9700 desktop, nothing
else running, on version afaf544, against llama.cpp 1.0.0 (build b12359, Vulkan, flash attention) with identical
settings. Conditions are in Performance.
| What | LexiEngine | llama.cpp 1.0.0 |
|---|---|---|
| Qwen3.8 27B Q4_K_M, 262,144-token context, 4-bit K/V cache, draft-head speculation: generation, short prompt | 76.8 tok/s | 65.3 tok/s |
| Same, generation after a 3,600-token prompt | 71.4 tok/s | 57.0 tok/s |
| Same, generation after a 33,000-token prompt | 70.0 tok/s | 55.8 tok/s |
| Same, generation after a 134,000-token prompt | 50.4 tok/s | device lost, no result |
| Same, generation after a 262,000-token prompt (the full window) | 39.9 tok/s | no result |
| Same, prompt processing, 3,600 tok... |
LexiSuite Testing Image 10
LexiSuite
LexiSuite is a complete, self-contained platform for running AI models on your own hardware, written in Rust from
the kernel up. One codebase contains the operating system (LexiOS), a kernel designed around inference
(LexiKernel), the inference engine that runs the models on the GPU (LexiEngine), and the browser control panel that
operates all of it (LexiPanel), together with its own virtual machine monitor, training and quantization tools. It
boots from one USB image. Nothing in it depends on a cloud service.
It is not a wrapper around llama.cpp, Ollama, vLLM or PyTorch. The inference engine, its GPU kernels, the scheduler,
the samplers and the HTTP APIs are original Rust and GLSL/CUDA code, and on the cards it is tuned for it is measured
against the newest llama.cpp release on every change (see The numbers).
It is developed every day by its author as their own primary AI platform. The test counts and the benchmark dates in
this file are all from the current week.
Current version: 5db82d6, 11/13/2026. The USB image, the source, this page, the wiki and
lexipanel.com all describe this one version.
Download: the development USB image 5db82d6 is on the download page at
lexipanel.com/download; the images before it are on Hugging Face at
huggingface.co/Wa1k3r/LexiSuite. It passed its virtual-machine qualification, and its LexiKernel is the one that boots a Ryzen desktop (MSI X570, Ryzen 9 5900X). Earlier images are at
github.com/W61k3r/LexiSuite-Releases/releases; the user
guide is the wiki. Flash the image to a USB stick, boot it, and
open the address shown on the screen.
OS / Kernel / Engine / Panel. All Rust.
What it is •
Why nothing else is like it •
The numbers •
What it does •
Architecture •
Performance •
Models •
Quick start •
API •
Hardware •
Security •
Status •
License
What it is
LexiSuite is four products built to work as one system:
| Component | What it is | Where |
|---|---|---|
| LexiEngine | Native Rust inference server: GGUF models on Vulkan, CUDA and CPU, with OpenAI-compatible and Anthropic Messages-compatible HTTP APIs | lexipanel-rs/engine |
| LexiPanel | Authenticated browser control plane for models, instances, GPUs, storage, fleets, training and virtual machines: 1,162 features, 58 guided tasks | lexipanel-rs |
| LexiOS | Rust-first appliance OS that boots straight into the Panel (Linux 7.4-rc2 in the newest image): init, network, firewall, storage, setup, updates | lexios |
| LexiKernel | Rust kernel with a Linux ABI, built around inference workloads; has booted real hardware and served the Panel from it | lexios/lexikernel |
Who it is for: anyone who wants to run large language models on hardware they own (one desktop GPU up to a small
fleet) and wants one system to do it, instead of assembling and maintaining a dozen separate projects.
What you get, concretely:
- Plug in a USB stick, boot, open a browser. The machine finds its GPUs, checks the engine can use them, and
shows the Panel on the network. Download a model from the Panel and chat with it or point any OpenAI or Anthropic
client at it. - An engine that is faster than llama.cpp where it has been tuned, and says where it is not. Measured on 11/13/2026
on a Radeon RX 7900 XTX against llama.cpp b12318 with the same settings: on a 27B model at a 262,144-token
context it generates 17% to 25% faster and reads prompts 27% to 29% faster up to 33,000 tokens, and it completed
the 134,000-token and 253,000-token prompts that llama.cpp could not (its Vulkan device was lost before the end of
the 134,000-token prompt in two of two attempts). - Everything else an AI box needs, in the same GUI: model library and downloads, per-GPU instances, benchmarks
against a reference engine, automatic parameter optimization, quantization to fit a card, LoRA training, typed
decisions with probabilities, agents with per-tool permissions, users and API keys, backups, updates, a fleet view,
virtual machines with GPU passthrough, a file manager and a terminal. - Security that is tested, not asserted: about 4,200 of the 16,395 tests exist to prove that something is refused.
Why nothing else is like it
Local AI today is an archipelago: an inference server from one project, a chat front end from another, a general
Linux distribution under them, a hypervisor from a fourth, quantization and training scripts from a fifth, and
monitoring bolted on. Each is an island, and the person running the box is the ferry.
LexiSuite is self-contained like an island, but it is the size of a continent: every one of those layers is in one
Rust codebase, built to the same rules, tested together and shipped as one image.
| Layer | What people normally assemble | In LexiSuite |
|---|---|---|
| Kernel | Linux, general purpose | LexiKernel: Rust, Linux ABI, inference-first scheduling, VRAM admission, IOMMU required. Linux 7.4 is the other boot entry on the same stick |
| Operating system | Ubuntu, Debian, Proxmox, a NAS distribution | LexiOS: boots into the Panel; firewall verified by PID 1; signed updates with rollback; self-test on every boot |
| Inference engine | llama.cpp, Ollama, vLLM, LM Studio | LexiEngine: original Rust engine with its own Vulkan and CUDA kernels. Upstream llama.cpp can also be installed from the Panel and run beside it |
| APIs | Whatever the server offers | OpenAI Chat, Completions and Responses, Anthropic Messages, embeddings, rerank, image generation, and typed decisions (/v1/decide) |
| Control panel and chat | Open WebUI, LM Studio, a dashboard, SSH | LexiPanel: one authenticated GUI for every operation on the box, including chat |
| Tuning | Hand-edited flags and forum posts | Benchmarks, an optimizer that keeps measured winners, GPU power caps, Fit (requantize a model to a card) |
| Training | Separate Python environments | LexiML: LoRA fine-tuning and gate training from the Panel or lexi-train |
| Virtual machines | QEMU, Proxmox | lexi-vmm: a safe-Rust VM monitor on KVM with virtio devices, VFIO passthrough and snapshots |
| Diagnostics | Logs scattered across tools | Live hardware view, crash evidence kept across restarts, one-click debug kits |
| Fleet | Ansible, scripts | Signed, opt-in remote actions across boxes from one Panel |
What follows from owning every layer:
- Problems are fixed where they are, not worked around. When the engine needed the GPU's memory accounting to be
exact at a 240,000-token context, the allocator, the admission rule and the kernel interface were all in reach. - One rule set. The same permission function decides every page, form and guided-task step; the same fail-closed
policy applies from the boot loader to an HTTP route. - One language. 1.92 million lines of Rust in 340 crates;
unsafeis confined to drivers, hardware paths and
FFI boundaries. - It can be reasoned about by one person, or one AI. The whole system is in one repository with one build.
Comparisons in one line each:
- llama.cpp / Ollama / LM Studio are inference engines or desktop apps. LexiSuite includes an engine of that
class and also the OS, kernel, control plane, VM host and tooling around it. - vLLM / TGI are datacenter serving stacks for Python environments. LexiSuite targets owned desktop and
workstation GPUs and has no Python in the serving path. - Open WebUI and similar are front ends for someone else's engine. LexiPanel operates the whole machine.
- Proxmox / TrueNAS are appliance operating systems for VMs and storage. LexiOS is that kind of appliance for
inference, with its own engine.
The numbers
All measured on one Radeon RX 7900 XTX (24 GB, capped at 291 W) in an Intel i7-9700 desktop, nothing else running,
against llama.cpp (Vulkan, flash attention) with identical settings: release b12318 on 11/13/2026 for the 27B rows,
on version 5db82d6, and release b12230 on 11/10/2026 for the 9B and DeepSeek rows. Dates and commits are in
Performance.
| What | LexiEngine | llama.cpp |
|---|---|---|
| Qwen3.8 27B Q4_K_M, 262,144-token context, 4-bit K/V cache, draft-head speculation: generation, short prompt | 76.5 tok/s | 64.9 tok/s |
| Same, generation after a 3,600-token prompt | 71.7 tok/s | 57.2 tok/s |
| Same, generation after a 33,000-token prompt | 70.2 tok/s | 55.8 tok/s |
| Same, generation after a 134,000-token prompt | 50.8 tok/s | device lost, no result (2 of 2 attempts) |
| Same, generation after a 253,000-token prompt | 40.2 tok/s | not reachable... |
LexiSuite Testing Image 9
LexiSuite
LexiSuite is a complete, self-contained platform for running AI models on your own hardware, written in Rust from
the kernel up. One codebase contains the operating system (LexiOS), a kernel designed around inference
(LexiKernel), the inference engine that runs the models on the GPU (LexiEngine), and the browser control panel that
operates all of it (LexiPanel), together with its own virtual machine monitor, training and quantization tools. It
boots from one USB image. Nothing in it depends on a cloud service.
It is not a wrapper around llama.cpp, Ollama, vLLM or PyTorch. The inference engine, its GPU kernels, the scheduler,
the samplers and the HTTP APIs are original Rust and GLSL/CUDA code, and on the cards it is tuned for it is measured
against the newest llama.cpp release on every change (see The numbers).
It is developed every day by its author as their own primary AI platform. The test counts and the benchmark dates in
this file are all from the current week.
Current version: 3db31f8, 11/12/2026. The USB image, the source, this page, the wiki and
lexipanel.com all describe this one version.
Download: the development USB image 3db31f8 is on Hugging Face at
huggingface.co/Wa1k3r/LexiSuite and on the download page at
lexipanel.com/download. It passed its virtual-machine qualification and boots LexiKernel on a Ryzen desktop (MSI X570, Ryzen 9 5900X). Earlier images are at
github.com/W61k3r/LexiSuite-Releases/releases; the user
guide is the wiki. Flash the image to a USB stick, boot it, and
open the address shown on the screen.
OS / Kernel / Engine / Panel. All Rust.
What it is •
Why nothing else is like it •
The numbers •
What it does •
Architecture •
Performance •
Models •
Quick start •
API •
Hardware •
Security •
Status •
License
What it is
LexiSuite is four products built to work as one system:
| Component | What it is | Where |
|---|---|---|
| LexiEngine | Native Rust inference server: GGUF models on Vulkan, CUDA and CPU, with OpenAI-compatible and Anthropic Messages-compatible HTTP APIs | lexipanel-rs/engine |
| LexiPanel | Authenticated browser control plane for models, instances, GPUs, storage, fleets, training and virtual machines: 1,162 features, 58 guided tasks | lexipanel-rs |
| LexiOS | Rust-first appliance OS that boots straight into the Panel (Linux 7.4-rc2 in the newest image): init, network, firewall, storage, setup, updates | lexios |
| LexiKernel | Rust kernel with a Linux ABI, built around inference workloads; has booted real hardware and served the Panel from it | lexios/lexikernel |
Who it is for: anyone who wants to run large language models on hardware they own (one desktop GPU up to a small
fleet) and wants one system to do it, instead of assembling and maintaining a dozen separate projects.
What you get, concretely:
- Plug in a USB stick, boot, open a browser. The machine finds its GPUs, checks the engine can use them, and
shows the Panel on the network. Download a model from the Panel and chat with it or point any OpenAI or Anthropic
client at it. - An engine that is faster than llama.cpp where it has been tuned, and says where it is not. Measured this week
on a Radeon RX 7900 XTX against llama.cpp b12230: ahead on a 27B model at every context length from a short
prompt to 231,000 tokens, and it completed the 138,000-token and 231,000-token cases that llama.cpp could not
(its Vulkan device was lost at 138,000 tokens in three of three attempts). - Everything else an AI box needs, in the same GUI: model library and downloads, per-GPU instances, benchmarks
against a reference engine, automatic parameter optimization, quantization to fit a card, LoRA training, typed
decisions with probabilities, agents with per-tool permissions, users and API keys, backups, updates, a fleet view,
virtual machines with GPU passthrough, a file manager and a terminal. - Security that is tested, not asserted: about 4,200 of the 16,361 tests exist to prove that something is refused.
Why nothing else is like it
Local AI today is an archipelago: an inference server from one project, a chat front end from another, a general
Linux distribution under them, a hypervisor from a fourth, quantization and training scripts from a fifth, and
monitoring bolted on. Each is an island, and the person running the box is the ferry.
LexiSuite is self-contained like an island, but it is the size of a continent: every one of those layers is in one
Rust codebase, built to the same rules, tested together and shipped as one image.
| Layer | What people normally assemble | In LexiSuite |
|---|---|---|
| Kernel | Linux, general purpose | LexiKernel: Rust, Linux ABI, inference-first scheduling, VRAM admission, IOMMU required. Linux 7.4 is the other boot entry on the same stick |
| Operating system | Ubuntu, Debian, Proxmox, a NAS distribution | LexiOS: boots into the Panel; firewall verified by PID 1; signed updates with rollback; self-test on every boot |
| Inference engine | llama.cpp, Ollama, vLLM, LM Studio | LexiEngine: original Rust engine with its own Vulkan and CUDA kernels. Upstream llama.cpp can also be installed from the Panel and run beside it |
| APIs | Whatever the server offers | OpenAI Chat, Completions and Responses, Anthropic Messages, embeddings, rerank, image generation, and typed decisions (/v1/decide) |
| Control panel and chat | Open WebUI, LM Studio, a dashboard, SSH | LexiPanel: one authenticated GUI for every operation on the box, including chat |
| Tuning | Hand-edited flags and forum posts | Benchmarks, an optimizer that keeps measured winners, GPU power caps, Fit (requantize a model to a card) |
| Training | Separate Python environments | LexiML: LoRA fine-tuning and gate training from the Panel or lexi-train |
| Virtual machines | QEMU, Proxmox | lexi-vmm: a safe-Rust VM monitor on KVM with virtio devices, VFIO passthrough and snapshots |
| Diagnostics | Logs scattered across tools | Live hardware view, crash evidence kept across restarts, one-click debug kits |
| Fleet | Ansible, scripts | Signed, opt-in remote actions across boxes from one Panel |
What follows from owning every layer:
- Problems are fixed where they are, not worked around. When the engine needed the GPU's memory accounting to be
exact at a 240,000-token context, the allocator, the admission rule and the kernel interface were all in reach. - One rule set. The same permission function decides every page, form and guided-task step; the same fail-closed
policy applies from the boot loader to an HTTP route. - One language. 1.92 million lines of Rust in 340 crates;
unsafeis confined to drivers, hardware paths and
FFI boundaries. - It can be reasoned about by one person, or one AI. The whole system is in one repository with one build.
Comparisons in one line each:
- llama.cpp / Ollama / LM Studio are inference engines or desktop apps. LexiSuite includes an engine of that
class and also the OS, kernel, control plane, VM host and tooling around it. - vLLM / TGI are datacenter serving stacks for Python environments. LexiSuite targets owned desktop and
workstation GPUs and has no Python in the serving path. - Open WebUI and similar are front ends for someone else's engine. LexiPanel operates the whole machine.
- Proxmox / TrueNAS are appliance operating systems for VMs and storage. LexiOS is that kind of appliance for
inference, with its own engine.
The numbers
All measured on one Radeon RX 7900 XTX (24 GB, capped at 291 W) in an Intel i7-9700 desktop, nothing else running,
against llama.cpp release b12230 (Vulkan, flash attention) with identical settings. Dates and commits are in
Performance.
| What | LexiEngine | llama.cpp b12230 |
|---|---|---|
| Qwen3.8 27B Q4_K_M, 240,128-token context, draft-head speculation: generation, short prompt | 61.8 tok/s | 53.1 tok/s |
| Same, 68,000 tokens of context | 56.4 tok/s | 44.3 tok/s |
| Same, 138,000 tokens of context | 48.9 tok/s | device lost, no result (3 of 3 attempts) |
| Same, 231,000 tokens of context | 42.2 tok/s | not reachable |
| Same, prompt processing at 68,000 tokens | 637 tok/s | 496 tok/s |
| 9B Qwen3.5-family model (Qwythos 9B Q4_K_M), 524,288-token context: generation at 509,000 tokens deep | 49.9 tok/s | 33.8 tok/s |
| Same, prompt processing at 509,000 tokens | 656 tok/s | 339 tok/s |
| DeepSeek-V2-Lite Q4_K_M: generation at 14,000 tokens of context | 159.0 tok/s | 110.1 tok/s ... |
LexiSuite Testing Image 8
LexiSuite
LexiSuite is a complete, self-contained platform for running AI models on your own hardware, written in Rust from
the kernel up. One codebase contains the operating system (LexiOS), a kernel designed around inference
(LexiKernel), the inference engine that runs the models on the GPU (LexiEngine), and the browser control panel that
operates all of it (LexiPanel), together with its own virtual machine monitor, training and quantization tools. It
boots from one USB image. Nothing in it depends on a cloud service.
It is not a wrapper around llama.cpp, Ollama, vLLM or PyTorch. The inference engine, its GPU kernels, the scheduler,
the samplers and the HTTP APIs are original Rust and GLSL/CUDA code, and on the cards it is tuned for it is measured
against the newest llama.cpp release on every change (see The numbers).
It is developed every day by its author as their own primary AI platform. The test counts and the benchmark dates in
this file are all from the current week.
Download: development USB images are published at
[github.com/W61k3r/LexiSuite-Releases/releases; the user
guide is the wiki.](https://github.com/W61k3r/LexiSuite-Releases/releases/download/LexiSuiteT8/LexiSuite-795b4a9-secureboot-dev.img.xz)
Flash the image to a USB stick, boot it, and
open the address shown on the screen.
OS / Kernel / Engine / Panel. All Rust.
What it is •
Why nothing else is like it •
The numbers •
What it does •
Architecture •
Performance •
Models •
Quick start •
API •
Hardware •
Security •
Status •
License
What it is
LexiSuite is four products built to work as one system:
| Component | What it is | Where |
|---|---|---|
| LexiEngine | Native Rust inference server: GGUF models on Vulkan, CUDA and CPU, with OpenAI-compatible and Anthropic Messages-compatible HTTP APIs | lexipanel-rs/engine |
| LexiPanel | Authenticated browser control plane for models, instances, GPUs, storage, fleets, training and virtual machines: 1,158 features, 58 guided tasks | lexipanel-rs |
| LexiOS | Rust-first appliance OS that boots straight into the Panel (Linux 7.4-rc2 in the newest image): init, network, firewall, storage, setup, updates | lexios |
| LexiKernel | Rust kernel with a Linux ABI, built around inference workloads; has booted real hardware and served the Panel from it | lexios/lexikernel |
Who it is for: anyone who wants to run large language models on hardware they own (one desktop GPU up to a small
fleet) and wants one system to do it, instead of assembling and maintaining a dozen separate projects.
What you get, concretely:
- Plug in a USB stick, boot, open a browser. The machine finds its GPUs, checks the engine can use them, and
shows the Panel on the network. Download a model from the Panel and chat with it or point any OpenAI or Anthropic
client at it. - An engine that is faster than llama.cpp where it has been tuned, and says where it is not. Measured this week
on a Radeon RX 7900 XTX against llama.cpp b12230: ahead on a 27B model at every context length from a short
prompt to 231,000 tokens, and it completed the 138,000-token and 231,000-token cases that llama.cpp could not
(its Vulkan device was lost at 138,000 tokens in three of three attempts). - Everything else an AI box needs, in the same GUI: model library and downloads, per-GPU instances, benchmarks
against a reference engine, automatic parameter optimization, quantization to fit a card, LoRA training, typed
decisions with probabilities, agents with per-tool permissions, users and API keys, backups, updates, a fleet view,
virtual machines with GPU passthrough, a file manager and a terminal. - Security that is tested, not asserted: about 4,600 of the 15,607 tests exist to prove that something is refused.
Why nothing else is like it
Local AI today is an archipelago: an inference server from one project, a chat front end from another, a general
Linux distribution under them, a hypervisor from a fourth, quantization and training scripts from a fifth, and
monitoring bolted on. Each is an island, and the person running the box is the ferry.
LexiSuite is self-contained like an island, but it is the size of a continent: every one of those layers is in one
Rust codebase, built to the same rules, tested together and shipped as one image.
| Layer | What people normally assemble | In LexiSuite |
|---|---|---|
| Kernel | Linux, general purpose | LexiKernel: Rust, Linux ABI, inference-first scheduling, VRAM admission, IOMMU required. Linux 7.4 is the other boot entry on the same stick |
| Operating system | Ubuntu, Debian, Proxmox, a NAS distribution | LexiOS: boots into the Panel; firewall verified by PID 1; signed updates with rollback; self-test on every boot |
| Inference engine | llama.cpp, Ollama, vLLM, LM Studio | LexiEngine: original Rust engine with its own Vulkan and CUDA kernels. Upstream llama.cpp can also be installed from the Panel and run beside it |
| APIs | Whatever the server offers | OpenAI Chat, Completions and Responses, Anthropic Messages, embeddings, rerank, image generation, and typed decisions (/v1/decide) |
| Control panel and chat | Open WebUI, LM Studio, a dashboard, SSH | LexiPanel: one authenticated GUI for every operation on the box, including chat |
| Tuning | Hand-edited flags and forum posts | Benchmarks, an optimizer that keeps measured winners, GPU power caps, Fit (requantize a model to a card) |
| Training | Separate Python environments | LexiML: LoRA fine-tuning and gate training from the Panel or lexi-train |
| Virtual machines | QEMU, Proxmox | lexi-vmm: a safe-Rust VM monitor on KVM with virtio devices, VFIO passthrough and snapshots |
| Diagnostics | Logs scattered across tools | Live hardware view, crash evidence kept across restarts, one-click debug kits |
| Fleet | Ansible, scripts | Signed, opt-in remote actions across boxes from one Panel |
What follows from owning every layer:
- Problems are fixed where they are, not worked around. When the engine needed the GPU's memory accounting to be
exact at a 240,000-token context, the allocator, the admission rule and the kernel interface were all in reach. - One rule set. The same permission function decides every page, form and guided-task step; the same fail-closed
policy applies from the boot loader to an HTTP route. - One language. 1.85 million lines of Rust in 339 crates;
unsafeis confined to drivers, hardware paths and
FFI boundaries. - It can be reasoned about by one person, or one AI. The whole system is in one repository with one build.
Comparisons in one line each:
- llama.cpp / Ollama / LM Studio are inference engines or desktop apps. LexiSuite includes an engine of that
class and also the OS, kernel, control plane, VM host and tooling around it. - vLLM / TGI are datacenter serving stacks for Python environments. LexiSuite targets owned desktop and
workstation GPUs and has no Python in the serving path. - Open WebUI and similar are front ends for someone else's engine. LexiPanel operates the whole machine.
- Proxmox / TrueNAS are appliance operating systems for VMs and storage. LexiOS is that kind of appliance for
inference, with its own engine.
The numbers
All measured on one Radeon RX 7900 XTX (24 GB, capped at 291 W) in an Intel i7-9700 desktop, nothing else running,
against llama.cpp release b12230 (Vulkan, flash attention) with identical settings. Dates and commits are in
Performance.
| What | LexiEngine | llama.cpp b12230 |
|---|---|---|
| Qwen3.8 27B Q4_K_M, 240,128-token context, draft-head speculation: generation, short prompt | 61.8 tok/s | 53.1 tok/s |
| Same, 68,000 tokens of context | 56.4 tok/s | 44.3 tok/s |
| Same, 138,000 tokens of context | 48.9 tok/s | device lost, no result (3 of 3 attempts) |
| Same, 231,000 tokens of context | 42.2 tok/s | not reachable |
| Same, prompt processing at 68,000 tokens | 637 tok/s | 496 tok/s |
| 9B Qwen3.5-family model (Qwythos 9B Q4_K_M), 524,288-token context: generation at 509,000 tokens deep | 49.9 tok/s | 33.8 tok/s |
| Same, prompt processing at 509,000 tokens | 656 tok/s | 339 tok/s |
| DeepSeek-V2-Lite Q4_K_M: generation at 14,000 tokens of context | 159.0 tok/s | 110.1 tok/s |
| DeepSeek-V2-Lite Q4_K_M: generation, short prompt | 215.6 tok/s | 245.6 tok/s |
| Largest context the engine accepts | 1,048,576 tokens | |
| Rust source | 1,849,949 lines in 4,112 files, 339 crates | |
| Tests | 15,607 test functions; about 4,600 prove a refusal | |
| Panel | 1,158 registered features, 58 guided tasks | |
| GPU kernels | 137 shad... |
LexiSuite Testing Image 7
LexiSuite
DOWNLOAD LINK
https://github.com/W61k3r/LexiSuite-Releases/releases/download/LexiSuiteT7/LexiSuite-c4ce6d8-secureboot-dev.img.xz
OS / Kernel / Engine / Panel. All Rust.
A complete local inference stack, from the kernel that boots the machine to the browser
panel that runs it. Your hardware, your models, nothing in the cloud.
Overview •
Architecture •
Performance •
Models •
Quick start •
API •
Hardware •
Status •
License
Overview
LexiSuite is four products built to work as one system:
| Component | What it is | Where |
|---|---|---|
| LexiEngine | Native Rust inference server: GGUF models on Vulkan, CUDA and CPU, with compatible HTTP APIs | lexipanel-rs/engine |
| LexiPanel | Authenticated browser control plane for models, instances, GPUs, storage, fleets and virtual machines | lexipanel-rs |
| LexiOS | Rust-first appliance OS (Linux 7.4-rc1 in the current images): init, network, firewall, storage, setup, updates | lexios |
| LexiKernel | Rust kernel with a Linux ABI, built around inference workloads | lexios/lexikernel |
Why build the whole stack:
- It's fast on real cards. On the 7900 XTX, LexiEngine is ahead of or level with the newest llama.cpp release
(b12180) on Qwen3.8 27B in every case measured on 11/06-11/07/2026 (enginebd315194): 12-24% faster without
speculation, up to 24% faster with draft-head speculation at long context, and 6-22% faster at prompt processing.
See Performance. - One Rust codebase. 1.85 million lines across 336 crates, from boot code to the browser UI.
- Local by design. Models, prompts and data stay on your machine.
- It boots from a stick. One USB image carries LexiOS on Linux 7.4-rc1 and LexiKernel side by side, boots with
Secure Boot on once its development certificate is enrolled, and LexiKernel has booted real hardware and served
the Panel from it. - Security is the default, not an option. Fail-closed checks at every layer, from the boot loader to the HTTP
routes, and about 4,600 tests whose job is to prove that something is refused. See Security.
What it does
LexiPanel: every operation in one browser GUI
One Panel, one interface: every page is rendered by the Panel server inside one shell with one navigation, and /
opens the overview. 1,158 features are recorded in one registry, and every control shows its tooltip from it. The
search box finds any feature by name. 58 guided tasks walk through multi-step jobs end to end (serve your first
model, fit a model to this GPU, benchmark fairly against the newest reference build, back up and move the
configuration, join a box and sync a model, boot an installer with GPU passthrough, import a TokenGate checkpoint and
more): each step calls the same routes the pages use, with the signed-in user's own permissions, shows its result
and offers undo where a step can be reversed. One permission rule decides every page, form and task step, so a
viewer is never offered an administrator's page.
| Area | Pages |
|---|---|
| Run models | Instances and parameters, engines and builds (LexiEngine, or an upstream llama.cpp release installed from the Builds tab), model library, download and upload, templates, chat (LexiChat), agents with per-tool permissions |
| Measure and improve | Bench and benchmark comparison, Optimize and the optimization lab, Fit, GPU tuning and power caps, Train, Evaluate, Qualification, Lexification |
| Operate | Status, statistics, metrics, logs, alerts, notifications, incidents, crash evidence, diagnostics and debug kits, hardware, workload, fleet and fabric, network, storage, backups with A/B recovery, maintenance, power options, virtual machines, files, terminal |
| Help | Guided tasks, feature search, the feature reference and the first-run walkthrough |
| Secure and administer | Access (users, roles, API keys), a sealed password vault, LexiGuard, appliance setup, licence and media, settings, appearance, release controls |
The Panel also serves OpenAI-compatible and Anthropic Messages-compatible APIs, so existing clients work unchanged.
LexiEngine: inference
- Back ends: Vulkan (AMD, Intel, NVIDIA), CUDA and CPU, measured on real cards; HIP, Metal and others are in the
tree. GGUF models; model code covers Llama, Mistral/Phi, Qwen and Gemma (including hybrid DeltaNet/attention
Qwen3.5 and 3.8), DeepSeek/GLM, gpt-oss and hybrid state-space models. - Speed features: multi-token prediction (MTP) and n-gram speculative decoding, a paged multi-sequence KV cache,
a cross-request radix prefix cache, shape-cached graph fusion, and tuned RDNA3 decode and attention kernels. - Adapters: GGUF LoRA adapters and control vectors, loaded at start or selected per request.
- TokenGate: learned prefill token gating (arXiv 2610.26754). Imports a published PyTorch checkpoint and serves
it, trains new gates, and has gate kernels for the CPU, Vulkan (passing on the RX 7900 XTX) and CUDA (passing on
the RTX 2060). The Panel imports, binds, trains and compares gates. Gated serving is not yet faster than ungated in
our runs.
Typed decisions
POST /v1/decide turns a model into a decision engine: yes/no, a 0-5 score, or one choice among 2-256 options,
answered in a single forward pass with a probability for every option. Decision heads (closed-form heads on hidden
states and rank-32 LoRA decision adapters) and an Auto-fit policy pick the readout. On the 7900 XTX with Qwen3.8 27B
and a rank-32 adapter, all 60 cases of a small synthetic labelled set were correct with an expected calibration
error of 0.72% (7.89% without the adapter). This is a functional check, not a general calibration claim.
Memory tiering and engram offload
Models larger than VRAM are placed tier by tier, explicitly:
--engram-tier auto|ram|nvme|gpu:deviceplaces per-layer n-gram embedding tables ("engrams", 27 GB in some models)
in RAM, on NVMe or on a chosen GPU.--expert-placement auto|gpu|ram|split, an expert cache and GPU warm sets place mixture-of-experts weights.- Tiered execution keeps parameters at home in CPU memory with a bounded GPU LRU, schedule-ahead staging and
optional NVMe spill; a strict memory planner does layer offload. - Placement modes that are not wired for a model fail closed with a reason instead of silently running slower.
An AI-first OS
LexiOS exists to run models, nothing else. It boots straight into the Panel, finds the GPUs and their drivers,
checks that the inference engine can use them, and keeps the system small enough to reason about. LexiKernel goes
further and puts inference into the kernel's own design: an inference-first scheduling policy, serialized VRAM
admission with pinned inference allocations and explicit LRU migration, kernel-mediated KV block residency across
VRAM, pinned host memory and storage, a read-mostly page cache for model files, GPU telemetry and tuning, and a
versioned /dev/lexi-inference interface for engines.
Visibility and diagnostics
- Live view: a live hardware view streamed to the browser (CPU, memory, GPUs with clocks, power, temperatures and
VRAM), per-instance status, statistics and metrics, logs, alerts, notifications and incidents. - Consoles: both kernels draw a status console on the machine's own screen: the Panel address, network, GPU
devices and runtime, storage, Secure Boot and signing state, and the boot self-test summary. - Self-test: every LexiOS boot runs a self-test and records each check as passed, blocked or not run, with the
reason, instead of claiming more than it proved. - Debug kits: one click collects a boot collection (hardware, PCI, ACPI tables, IOMMU state, kernel and
LexiKernel logs, firmware, storage, engine capabilities and topology, the self-test and the Panel's failed-request
log) into one archive with a manifest, and never includes credentials. - Evidence over guesses: crash evidence is kept across restarts, LexiKernel writes its own log partition on the
boot stick, and engine start failures name their cause (for example the missing library).
Tuning, optimizing and fitting
- Fit: explains any GGUF (tensor types, sizes, where they will live) and plans requantization to fit a target
card, with recipes. The quantization tools include Hessian-aware grid initialisation, GSQ, RCO (Riemannian
constrained optimisation of per-tensor quantisation types), resumable calibration with activation Grams and BF16
teacher targets, and quality evaluation. - Optimize: runs benchmark suites over parameter profiles and keeps the measured winners; Lexification probes the
hardware, plans an inference strategy and qualifies it. - Tune: GPU power caps and tuning, boot-time power profiles, and a host inference profile (huge pages, pinned
decode threads) that the engine reads but never writes.
Virtual machines
lexi-vmm is the suite's own virtual machine monitor on K...
LexiSuite Testing Image 6
LexiSuite
DOWNLOAD LINK
https://github.com/W61k3r/LexiSuite-Releases/releases/download/LexiSuitet6/LexiSuite-051033e-secureboot-dev.img.xz
OS / Kernel / Engine / Panel. All Rust.
A complete local inference stack, from the kernel that boots the machine to the browser
panel that runs it. Your hardware, your models, nothing in the cloud.
Overview •
Architecture •
Performance •
Models •
Quick start •
API •
Hardware •
Status •
License
Overview
LexiSuite is four products built to work as one system:
| Component | What it is | Where |
|---|---|---|
| LexiEngine | Native Rust inference server: GGUF models on Vulkan, CUDA and CPU, with compatible HTTP APIs | lexipanel-rs/engine |
| LexiPanel | Authenticated browser control plane for models, instances, GPUs, storage and fleets | lexipanel-rs |
| LexiOS | Rust-first appliance OS on Linux 7.3: init, network, firewall, storage, setup, updates | lexios |
| LexiKernel | Rust kernel with a Linux ABI, built around inference workloads | lexios/lexikernel |
Why build the whole stack:
- It's fast on real cards. On the 7900 XTX with draft-head speculation, LexiEngine is level with or ahead of
llama.cpp on every 27B row measured on 11/03/2026, up to 30% faster, and processes prompts up to 22% faster.
See Performance. - One Rust codebase. 1.77 million lines across 324 crates, from boot code to the browser UI.
- Local by design. Models, prompts and data stay on your machine.
- It boots from a stick. A development USB image carries Linux 7.3 and LexiKernel side by side, and LexiKernel
has booted real hardware and served the Panel from it.
Architecture
flowchart TB
subgraph clients [Clients]
B[Browser]
A[API clients]
end
subgraph panel [LexiPanel]
P[Auth, instances, models, storage, fleet]
end
subgraph engine [LexiEngine]
H[HTTP APIs]
S[Scheduler and sampling]
M[Model graphs: Qwen, Gemma, DeepSeek]
V[Vulkan]
C[CUDA]
U[CPU]
end
subgraph os [LexiOS]
O[Init, network, firewall, storage, setup, updates]
end
subgraph kernels [Kernel, chosen at boot]
L[Linux 7.3]
K[LexiKernel]
end
subgraph hw [Hardware]
G[GPUs]
N[NVMe, USB, NICs]
end
B --> P
A --> H
P --> H
H --> S --> M
M --> V & C & U
P --> O
O --> L & K
V & C --> G
L & K --> NRepository layout
.
├── lexipanel-rs/
│ ├── crates/
│ │ ├── lexi/ Panel server and CLI tools
│ │ ├── lexi-gui/ Browser UI, compiled to WebAssembly
│ │ ├── installer/ Panel installer
│ │ ├── lexi-debugkit/ Support and boot diagnostics
│ │ ├── lexi-guard/ Tool permission gate
│ │ ├── lexi-hwinfo/ Hardware inventory
│ │ ├── lexi-vm/ VM support
│ │ └── xtask/ Build and release tasks
│ ├── engine/ LexiEngine workspace, 159 crates
│ ├── deploy/ Install scripts and packaging
│ └── third-party-licenses/
├── lexios/
│ ├── lexikernel/ LexiKernel: 99 crates
│ │ ├── crates/ Kernel subsystems
│ │ └── drivers/ NVMe, AHCI, xHCI, USB, virtio, NICs, GPU blocks
│ ├── tools/ LexiOS userland, 52 crates
│ ├── .lexios/ Policies, configuration, fixtures
│ └── third-party-licenses/
├── docs/ Binary test fixtures read by the test suites
├── experimental/ Research code, not shipped
└── tools/ Build helpers
Performance
Qwen3.8 27B on a Radeon RX 7900 XTX against the newest llama.cpp release (b12180, Vulkan, flash attention), measured
on 11/06/2026 on the same machine with the same harness: Intel i7-9700, XTX capped at 291 W, Linux 7.3, Q4_1 KV cache,
131,072-token context, one slot, no cache reuse, a random prefix on every prompt, idle box. Generation is tokens per
second after the first token, the median of three runs (68k is one request). Greedy output text is identical across
LexiEngine builds.
Headline: generation without speculation, short prompt
| Model | LexiEngine (this source) | llama.cpp b12180 | LexiEngine ahead by |
|---|---|---|---|
| IQ4_XS | 50.5 | 42.8 | +18% |
| Q4_K_M | 42.9 | 38.2 | +12% |
Generation (tok/s) at short / 3.6k / 21k / 68k tokens of context
Measured with the previous engine build c5dd9d0e; the engine in this source is faster again at short prompts
(table above), and its full table follows in the next update.
| Model and mode | LexiEngine c5dd9d0e |
llama.cpp b12180 |
|---|---|---|
| IQ4_XS, MTP | 79.3 / 86.9 / 74.7 / 63.6 | 68.6 / 78.6 / 65.7 / 55.7 |
| IQ4_XS, no MTP | 47.7 / 45.6 / 44.3 / 40.2 | 42.8 / 41.2 / 38.7 / 33.8 |
| Q4_K_M, MTP | 70.0 / 73.8 / 67.9 / 58.1 | 66.1 / 70.3 / 56.9 / 45.6 |
| Q4_K_M, no MTP | 38.9 / 37.5 / 36.3 / 33.5 | 38.2 / 36.6 / 34.8 / 30.8 |
Prompt processing (tok/s) at 3.6k / 21k / 68k tokens (LexiEngine c5dd9d0e vs llama.cpp b12177)
| Model | LexiEngine | llama.cpp | LexiEngine ahead by |
|---|---|---|---|
| IQ4_XS | 923 / 855 / 663 | 871 / 783 / 543 | 6% / 9% / 22% |
| Q4_K_M | 875 / 814 / 637 | 825 / 747 / 525 | 6% / 9% / 21% |
LexiEngine is ahead of llama.cpp in every measured case. The gains of 11/06 came from removing a per-allocation host
cost that left the GPU idle about 4.7 ms per token, half-subgroup and 64-lane Q4_K/Q6_K and eight-lane IQ4_XS decode
kernels, a long-context decode attention kernel (68k keys: 1029 to 321 us per layer), a recycled decode activation pool,
fused FFN gate/up/SwiGLU passes and a split DeltaNet step. Decode is GPU-bound; the next target is about 80% of the
card's 960 GB/s without speculation (about 47 tok/s on Q4_K_M and 53 on IQ4_XS for short prompts).
7900 XTX: Qwen3 1.7B Q4_K_M, LexiOS from the USB image (11/04, before the 11/06 engine work)
Measured on 11/04/2026 (UTC) on a second 7900 XTX (Ryzen 9 5900X), LexiOS on Linux 7.3 booted from the USB stick,
through the Panel over the network. Same model and settings on both engines: 8,192-token context, f16 KV cache,
one slot, 256 generated tokens, three runs each. llama.cpp b12090 (Vulkan) installed by the Panel's engine installer.
| LexiEngine | llama.cpp b12090 | |
|---|---|---|
| Generation, short prompt | 257-264 tok/s | 342-344 tok/s |
| Generation, 3,586-token prompt | 236-237 tok/s | 294-295 tok/s |
| First token, 3,586-token prompt | 0.84-0.90 s | 0.59-0.63 s |
| First token, short prompt | 0.04 s | 0.16-0.20 s |
On small models llama.cpp is 25-30% faster: at this speed LexiEngine's fixed per-token cost dominates. This is the
next performance target.
Status, 11/07/2026
- Development USB image with Secure Boot (Linux entry on 7.4-rc1): signed with the LexiSuite development certificate.
After that certificate is appended to the PC's db (the Microsoft keys stay), both menu entries boot with Secure Boot
on. Verified in a VM from an unenrolled state: LexiKernel first and second start (it creates and then reuses its
rollback-protection variable) and with an AMD IOMMU, Linux 7.4 to a working Panel, and refusals of a stick without
enrollment, a tampered rollback file and a tampered kernel. Not yet started on a physical Secure Boot PC. - Upstream llama.cpp runs on LexiOS without third-party libraries: LexiOS ships original Rust implementations of the
runtime interfaces it loads (libgomp, libcrypto, libssl). llama.cpp b12180 against them gives identical greedy text
on CPU and on Vulkan and the same speed (within 1%), and HTTPS model downloads work through its own HTTP client,
with certificate verification. TLS older than 1.2, TLS 1.2 without extended master secret, client certificates and
encrypted private keys are refused with a clear error. - On first boot the LEXIDATA partition and filesystem grow to fill the stick under either kernel, verified on a
physical stick and in a VM. - Panel, tested in a real headless browser on both kernels. Defects found this way are fixed (uploads into system
folders, storage status on a fresh install, start-at-boot without systemd, engine start errors that now name the
missing library, chat sends before the model list loads, the consoles' Secure Boot rows, LexiKernel's console page
on Secure Boot images). On LexiKernel, features it does not provide say so in the GUI. Open: storage usage
measurement and CPU usage on LexiKernel. - The Panel keeps a log of failed requests, so a debug kit records GUI failures.
- LexiKernel GPU: a native Rust AMD Navi 31 (RDNA3) driver is integrated as offline software and passes its mock and
kernel test suites. It has not run on hardware; GPU work under LexiKernel still uses the Linux driver-domain guest. - The image is development-signed, not production-signe...
LexiSuite Testing Image 3
LexiSuite
OS / Kernel / Engine / Panel. All Rust.
A complete local inference stack, from the kernel that boots the machine to the browser
panel that runs it. Your hardware, your models, nothing in the cloud.
Overview •
Architecture •
Performance •
Models •
Quick start •
API •
Hardware •
Status •
License
[All-In-One Image Download https://github.com/W61k3r/LexiSuite-Releases/releases/download/LexiSuitet3/LexiSuite-testing3.img.xz
Overview
LexiSuite is four products built to work as one system:
| Component | What it is | Where |
|---|---|---|
| LexiEngine | Native Rust inference server: GGUF models on Vulkan, CUDA and CPU, with compatible HTTP APIs | lexipanel-rs/engine |
| LexiPanel | Authenticated browser control plane for models, instances, GPUs, storage and fleets | lexipanel-rs |
| LexiOS | Rust-first appliance OS on Linux 7.3: init, network, firewall, storage, setup, updates | lexios |
| LexiKernel | Rust kernel with a Linux ABI, built around inference workloads | lexios/lexikernel |
Why build the whole stack:
- It's fast on real cards. On the 7900 XTX with draft-head speculation, LexiEngine is level with or ahead of
llama.cpp on every 27B row measured on 11/03/2026, up to 30% faster, and processes prompts up to 22% faster.
See Performance. - One Rust codebase. 1.77 million lines across 324 crates, from boot code to the browser UI.
- Local by design. Models, prompts and data stay on your machine.
- It boots from a stick. A development USB image carries Linux 7.3 and LexiKernel side by side, and LexiKernel
has booted real hardware and served the Panel from it.
Architecture
flowchart TB
subgraph clients [Clients]
B[Browser]
A[API clients]
end
subgraph panel [LexiPanel]
P[Auth, instances, models, storage, fleet]
end
subgraph engine [LexiEngine]
H[HTTP APIs]
S[Scheduler and sampling]
M[Model graphs: Qwen, Gemma, DeepSeek]
V[Vulkan]
C[CUDA]
U[CPU]
end
subgraph os [LexiOS]
O[Init, network, firewall, storage, setup, updates]
end
subgraph kernels [Kernel, chosen at boot]
L[Linux 7.3]
K[LexiKernel]
end
subgraph hw [Hardware]
G[GPUs]
N[NVMe, USB, NICs]
end
B --> P
A --> H
P --> H
H --> S --> M
M --> V & C & U
P --> O
O --> L & K
V & C --> G
L & K --> NRepository layout
.
├── lexipanel-rs/
│ ├── crates/
│ │ ├── lexi/ Panel server and CLI tools
│ │ ├── lexi-gui/ Browser UI, compiled to WebAssembly
│ │ ├── installer/ Panel installer
│ │ ├── lexi-debugkit/ Support and boot diagnostics
│ │ ├── lexi-guard/ Tool permission gate
│ │ ├── lexi-hwinfo/ Hardware inventory
│ │ ├── lexi-vm/ VM support
│ │ └── xtask/ Build and release tasks
│ ├── engine/ LexiEngine workspace, 159 crates
│ ├── deploy/ Install scripts and packaging
│ └── third-party-licenses/
├── lexios/
│ ├── lexikernel/ LexiKernel: 99 crates
│ │ ├── crates/ Kernel subsystems
│ │ └── drivers/ NVMe, AHCI, xHCI, USB, virtio, NICs, GPU blocks
│ ├── tools/ LexiOS userland, 52 crates
│ ├── .lexios/ Policies, configuration, fixtures
│ └── third-party-licenses/
├── docs/ Binary test fixtures read by the test suites
├── experimental/ Research code, not shipped
└── tools/ Build helpers
Performance
Qwen3.8 27B on a Radeon RX 7900 XTX, measured on 11/03/2026 against llama.cpp on the same machine in the same
session: LexiEngine from commit a7df5635, llama.cpp b11954 (Vulkan, flash attention). Intel i7-9700, XTX capped
at 291 W, Linux 7.3. Both use a Q4_1 KV cache and a 131,072-token context. Each prompt carries a random prefix,
so nothing is served from a cache.
short is "What is 2+2? Answer with just the number.", up to 64 tokens, three runs. 3.6k and 20k are prompts of
3,628 and 20,971 tokens, then up to 32 tokens. Generation is tokens per second after the first token; each figure
is the median of its runs. Draft-head speculation (MTP) proposes two tokens on both engines.
7900 XTX: Qwen3.8 27B IQ4_XS
| Row | LexiEngine | llama.cpp | |
|---|---|---|---|
| MTP, short | 72.3 | 62.4 | +16% |
| MTP, 3.6k | 77.0 | 76.0 | level |
| MTP, 20k | 66.8 | 66.8 | level |
| Prompt, 3.6k (tok/s) | 920 | 756 | +22% |
| Prompt, 20k (tok/s) | 844 | 712 | +19% |
| First token, 3.6k | 3.9 s | 4.8 s | 18% sooner |
| First token, 20k | 24.9 s | 29.4 s | 16% sooner |
| No MTP, short / 3.6k / 20k | 38.1 / 37.7 / 34.7 | 39.0 / 40.7 / 38.4 | 2 to 10% behind |
7900 XTX: Qwen3.8 27B Q4_K_M
| Row | LexiEngine | llama.cpp | |
|---|---|---|---|
| MTP, short | 69.4 | 59.9 | +16% |
| MTP, 3.6k | 69.9 | 55.7 | +25% |
| MTP, 20k | 68.3 | 52.6 | +30% |
| Prompt, 3.6k (tok/s) | 875 | 727 | +20% |
| Prompt, 20k (tok/s) | 804 | 679 | +18% |
| First token, 3.6k | 4.2 s | 5.0 s | 17% sooner |
| First token, 20k | 26.1 s | 30.9 s | 16% sooner |
| No MTP, short / 3.6k / 20k | 34.6 / 33.4 / 30.8 | 34.7 / 34.0 / 34.4 | level to 11% behind |
With draft-head speculation, the way the Panel runs it, LexiEngine is level with or ahead of llama.cpp in every row,
and its prompt processing is faster in every mode. Plain generation at long context is the remaining gap.
Other models and the RTX 2060 have not been re-measured on this commit, so they are not listed here.
7900 XTX: Qwen3 1.7B Q4_K_M, LexiOS from the USB image
Measured on 11/04/2026 (UTC) on a second 7900 XTX (Ryzen 9 5900X), LexiOS on Linux 7.3 booted from the USB stick,
through the Panel over the network. Same model and settings on both engines: 8,192-token context, f16 KV cache,
one slot, 256 generated tokens, three runs each. llama.cpp b12090 (Vulkan) installed by the Panel's engine installer.
| LexiEngine | llama.cpp b12090 | |
|---|---|---|
| Generation, short prompt | 257-264 tok/s | 342-344 tok/s |
| Generation, 3,586-token prompt | 236-237 tok/s | 294-295 tok/s |
| First token, 3,586-token prompt | 0.84-0.90 s | 0.59-0.63 s |
| First token, short prompt | 0.04 s | 0.16-0.20 s |
On small models llama.cpp is 25-30% faster: at this speed LexiEngine's fixed per-token cost dominates. This is the
next performance target.
Status, 11/04/2026
- USB release image built from this source: 3 GiB, no models. On first boot the LEXIDATA partition and filesystem
grow to fill the stick under either kernel (verified on a 32 GiB disk in a VM: Linux 7.3 and LexiKernel both reach
a working Panel). Not yet verified on a physical stick. - The image is signed with a development owner key, not a production key. With Secure Boot on, LexiKernel refuses
to start until that certificate is enrolled. - LexiKernel: the Intel I219 network driver now completes the PHY low-power exit and logs link and DHCP events;
the ThinkPad P71 gets its address within a second on two consecutive boots. The console does not yet show
LEXIDATA free space. - LexiKernel GPU: a native Rust AMD Navi 31 (RDNA3) driver has been integrated as offline software (firmware boot,
power, GPU memory, interrupts, compute queues, copy engines, reset, DRM render-node backend) and passes its mock
and kernel test suites. It has not run on hardware; GPU work under LexiKernel still uses the Linux driver-domain
guest. Vulkan on the native driver is not yet available. - Panel: every tab, including System, is served inside the one shared Panel shell.
Models
Architectures served per backend, as reported by lexi-engine --accelerator-capabilities-json:
| Architecture | CPU | Vulkan | CUDA |
|---|---|---|---|
| Qwen3 | Yes | Yes | Yes |
| Qwen3.5 / 3.8 hybrid | Yes | Yes | Yes |
| Gemma 4 | Yes | Yes | Yes |
| DeepSeek-V2 | Yes | Yes | Yes |
Measured here: Q4_K_M, IQ4_XS, Q8_0 and F16. Speculative decoding uses
the draft head embedded in MTP models. Also in the tree, at earlier stages: embeddings and reranking,
vision, speech, image generation and native quantization tools.
Install from the USB image
- Download
LexiSuite-testing.img.xzfrom Releases and check it againstSHA256SUMS. - Write it to a USB stick of 8 GB or more with balenaEtcher or Raspberry Pi Imager (both take the
.xzdirectly), or
xz -dc LexiSuite-testing.img.xz | sudo dd of=/dev/sdX bs=4M conv=fsync(this erases the stick). - Boot from the stick. Choose LexiKernel or Linux 7.3 at the menu. On first boot the data partition grows to fill
...
Testing Release Image 5
LexiSuite
OS / Kernel / Engine / Panel. All Rust.
A complete local inference stack, from the kernel that boots the machine to the browser
panel that runs it. Your hardware, your models, nothing in the cloud.
Overview •
Architecture •
Performance •
Models •
Quick start •
API •
Hardware •
Status •
License
[All-In-One Image Download https://github.com/W61k3r/LexiSuite-Releases/releases/download/LexiSuitet3/LexiSuite-testing5.img.xz
Overview
LexiSuite is four products built to work as one system:
| Component | What it is | Where |
|---|---|---|
| LexiEngine | Native Rust inference server: GGUF models on Vulkan, CUDA and CPU, with compatible HTTP APIs | lexipanel-rs/engine |
| LexiPanel | Authenticated browser control plane for models, instances, GPUs, storage and fleets | lexipanel-rs |
| LexiOS | Rust-first appliance OS on Linux 7.3: init, network, firewall, storage, setup, updates | lexios |
| LexiKernel | Rust kernel with a Linux ABI, built around inference workloads | lexios/lexikernel |
Why build the whole stack:
- It's fast on real cards. On the 7900 XTX with draft-head speculation, LexiEngine is level with or ahead of
llama.cpp on every 27B row measured on 11/03/2026, up to 30% faster, and processes prompts up to 22% faster.
See Performance. - One Rust codebase. 1.77 million lines across 324 crates, from boot code to the browser UI.
- Local by design. Models, prompts and data stay on your machine.
- It boots from a stick. A development USB image carries Linux 7.3 and LexiKernel side by side, and LexiKernel
has booted real hardware and served the Panel from it.
Architecture
flowchart TB
subgraph clients [Clients]
B[Browser]
A[API clients]
end
subgraph panel [LexiPanel]
P[Auth, instances, models, storage, fleet]
end
subgraph engine [LexiEngine]
H[HTTP APIs]
S[Scheduler and sampling]
M[Model graphs: Qwen, Gemma, DeepSeek]
V[Vulkan]
C[CUDA]
U[CPU]
end
subgraph os [LexiOS]
O[Init, network, firewall, storage, setup, updates]
end
subgraph kernels [Kernel, chosen at boot]
L[Linux 7.3]
K[LexiKernel]
end
subgraph hw [Hardware]
G[GPUs]
N[NVMe, USB, NICs]
end
B --> P
A --> H
P --> H
H --> S --> M
M --> V & C & U
P --> O
O --> L & K
V & C --> G
L & K --> NRepository layout
.
├── lexipanel-rs/
│ ├── crates/
│ │ ├── lexi/ Panel server and CLI tools
│ │ ├── lexi-gui/ Browser UI, compiled to WebAssembly
│ │ ├── installer/ Panel installer
│ │ ├── lexi-debugkit/ Support and boot diagnostics
│ │ ├── lexi-guard/ Tool permission gate
│ │ ├── lexi-hwinfo/ Hardware inventory
│ │ ├── lexi-vm/ VM support
│ │ └── xtask/ Build and release tasks
│ ├── engine/ LexiEngine workspace, 159 crates
│ ├── deploy/ Install scripts and packaging
│ └── third-party-licenses/
├── lexios/
│ ├── lexikernel/ LexiKernel: 99 crates
│ │ ├── crates/ Kernel subsystems
│ │ └── drivers/ NVMe, AHCI, xHCI, USB, virtio, NICs, GPU blocks
│ ├── tools/ LexiOS userland, 52 crates
│ ├── .lexios/ Policies, configuration, fixtures
│ └── third-party-licenses/
├── docs/ Binary test fixtures read by the test suites
├── experimental/ Research code, not shipped
└── tools/ Build helpers
Performance
Qwen3.8 27B on a Radeon RX 7900 XTX, measured on 11/03/2026 against llama.cpp on the same machine in the same
session: LexiEngine from commit a7df5635, llama.cpp b11954 (Vulkan, flash attention). Intel i7-9700, XTX capped
at 291 W, Linux 7.3. Both use a Q4_1 KV cache and a 131,072-token context. Each prompt carries a random prefix,
so nothing is served from a cache.
short is "What is 2+2? Answer with just the number.", up to 64 tokens, three runs. 3.6k and 20k are prompts of
3,628 and 20,971 tokens, then up to 32 tokens. Generation is tokens per second after the first token; each figure
is the median of its runs. Draft-head speculation (MTP) proposes two tokens on both engines.
7900 XTX: Qwen3.8 27B IQ4_XS
| Row | LexiEngine | llama.cpp | |
|---|---|---|---|
| MTP, short | 72.3 | 62.4 | +16% |
| MTP, 3.6k | 77.0 | 76.0 | level |
| MTP, 20k | 66.8 | 66.8 | level |
| Prompt, 3.6k (tok/s) | 920 | 756 | +22% |
| Prompt, 20k (tok/s) | 844 | 712 | +19% |
| First token, 3.6k | 3.9 s | 4.8 s | 18% sooner |
| First token, 20k | 24.9 s | 29.4 s | 16% sooner |
| No MTP, short / 3.6k / 20k | 38.1 / 37.7 / 34.7 | 39.0 / 40.7 / 38.4 | 2 to 10% behind |
7900 XTX: Qwen3.8 27B Q4_K_M
| Row | LexiEngine | llama.cpp | |
|---|---|---|---|
| MTP, short | 69.4 | 59.9 | +16% |
| MTP, 3.6k | 69.9 | 55.7 | +25% |
| MTP, 20k | 68.3 | 52.6 | +30% |
| Prompt, 3.6k (tok/s) | 875 | 727 | +20% |
| Prompt, 20k (tok/s) | 804 | 679 | +18% |
| First token, 3.6k | 4.2 s | 5.0 s | 17% sooner |
| First token, 20k | 26.1 s | 30.9 s | 16% sooner |
| No MTP, short / 3.6k / 20k | 34.6 / 33.4 / 30.8 | 34.7 / 34.0 / 34.4 | level to 11% behind |
With draft-head speculation, the way the Panel runs it, LexiEngine is level with or ahead of llama.cpp in every row,
and its prompt processing is faster in every mode. Plain generation at long context is the remaining gap.
Other models and the RTX 2060 have not been re-measured on this commit, so they are not listed here.
7900 XTX: Qwen3 1.7B Q4_K_M, LexiOS from the USB image
Measured on 11/04/2026 (UTC) on a second 7900 XTX (Ryzen 9 5900X), LexiOS on Linux 7.3 booted from the USB stick,
through the Panel over the network. Same model and settings on both engines: 8,192-token context, f16 KV cache,
one slot, 256 generated tokens, three runs each. llama.cpp b12090 (Vulkan) installed by the Panel's engine installer.
| LexiEngine | llama.cpp b12090 | |
|---|---|---|
| Generation, short prompt | 257-264 tok/s | 342-344 tok/s |
| Generation, 3,586-token prompt | 236-237 tok/s | 294-295 tok/s |
| First token, 3,586-token prompt | 0.84-0.90 s | 0.59-0.63 s |
| First token, short prompt | 0.04 s | 0.16-0.20 s |
On small models llama.cpp is 25-30% faster: at this speed LexiEngine's fixed per-token cost dominates. This is the
next performance target.
Status, 11/04/2026
- USB release image built from this source: 3 GiB, no models. On first boot the LEXIDATA partition and filesystem
grow to fill the stick under either kernel (verified on a 32 GiB disk in a VM: Linux 7.3 and LexiKernel both reach
a working Panel). Not yet verified on a physical stick. - The image is signed with a development owner key, not a production key. With Secure Boot on, LexiKernel refuses
to start until that certificate is enrolled. - LexiKernel: the Intel I219 network driver now completes the PHY low-power exit and logs link and DHCP events;
the ThinkPad P71 gets its address within a second on two consecutive boots. The console does not yet show
LEXIDATA free space. - LexiKernel GPU: a native Rust AMD Navi 31 (RDNA3) driver has been integrated as offline software (firmware boot,
power, GPU memory, interrupts, compute queues, copy engines, reset, DRM render-node backend) and passes its mock
and kernel test suites. It has not run on hardware; GPU work under LexiKernel still uses the Linux driver-domain
guest. Vulkan on the native driver is not yet available. - Panel: every tab, including System, is served inside the one shared Panel shell.
Models
Architectures served per backend, as reported by lexi-engine --accelerator-capabilities-json:
| Architecture | CPU | Vulkan | CUDA |
|---|---|---|---|
| Qwen3 | Yes | Yes | Yes |
| Qwen3.5 / 3.8 hybrid | Yes | Yes | Yes |
| Gemma 4 | Yes | Yes | Yes |
| DeepSeek-V2 | Yes | Yes | Yes |
Measured here: Q4_K_M, IQ4_XS, Q8_0 and F16. Speculative decoding uses
the draft head embedded in MTP models. Also in the tree, at earlier stages: embeddings and reranking,
vision, speech, image generation and native quantization tools.
Install from the USB image
- Download
LexiSuite-testing.img.xzfrom Releases and check it againstSHA256SUMS. - Write it to a USB stick of 8 GB or more with balenaEtcher or Raspberry Pi Imager (both take the
.xzdirectly), or
xz -dc LexiSuite-testing.img.xz | sudo dd of=/dev/sdX bs=4M conv=fsync(this erases the stick). - Boot from the stick. Choose LexiKernel or Linux 7.3 at the menu. On first boot the data partition grows to...