It really does run an 80B model on a 32 GB laptop, but the big margins over llama.cpp are the author's own and the whole thing is one person's experiment. We rate it 3.6 out of 5.

How much does Janas cost?

Free and open source under GPL-3.0 or later. No paid edition.

What are the downsides of Janas?

Headline llama.cpp margins are self-reported on one laptop; single maintainer; outside code cannot be merged yet; vulkan only, with wrong-output bugs on several GPUs; no macOS or ARM; experimental, with commands changing weekly.

How much does Janas cost for a team or in production?

No paid edition, so the cost is hardware: the reference machine is a 32 GB laptop with an NVMe SSD reading about 5.7 GB/s, and slower disks or a busy machine lower speed. The server's single-sequence design means scaling to many users means one machine per concurrent user.

Is Janas safe for company data?

Runs locally and writes only to ~/.cache/janas and wherever you put converted models; no telemetry is described. The server binds to 127.0.0.1 with no API key by default. GPL-3.0 or later for the code; converted models keep their own licences (Qwen's Apache 2.0, Qwen3.8-Flash-Next's Qwen Community License, DeepNSM's non-commercial CC BY-NC-SA).

What are the best Janas alternatives?

The closest alternatives we have reviewed are llama.cpp, Ollama and llamafile.

Janas GitHub repo review (updated)

What is Janas?

Janas, by Maurizio Cammalleri, is a set of AI tools written in C with no dependencies beyond the C library. Its main part, Janas-LLM, runs mixture-of-experts language models whose files are bigger than the machine's memory. The weights stay on disk; the experts each token needs are read from an NVMe SSD, and the ones that keep coming back are held in an expert cache that fills the free RAM.

It reads its own .jns format, converted from GGUF files (Q4_K_M and several other 3- to 5-bit types) or downloaded pre-converted from the project's Hugging Face account. Supported families are Qwen3, Qwen3.5, Qwen3.6, Qwen3-Next, Gemma 4 and Llama 3. Around the engine sit a terminal chat, janas-server (an OpenAI-style HTTP API), janas-mcp (the model as tools for MCP clients) and a C library.

The repo was created on 20 September 2026, has about 548 GitHub stars and 44 forks, and is licensed GPL-3.0 or later. It ships date-stamped releases for Linux and Windows on x86-64, the latest v2026.10.30.1 on 30 October. The README calls it an experiment, not a product.

Is Janas worth it?

Janas is a serious, unusually well documented attempt at running mixture-of-experts models that do not fit in memory, and its headline numbers should still be read as self-reported. The author's table, measured on one laptop (Intel Core Ultra 9 185H, 32 GB of RAM, an NVMe disk reading about 5.7 GB/s), has Qwen3-Next-80B, a 48.4 GB file, writing at 26.4 tok/s against 3.0 for llama.cpp and reading a prompt at 68.4 against 17.7. The repo's one-line description still quotes older figures, 37 tok/s and 2.8 for llama.cpp across 13 models; the README now lists 17 rows. The 37 comes from drafts, the model's own prediction block guessing tokens ahead that the model then checks, and in the chat the README gives 31-35 tok/s with a warm cache.

The trick is specific to mixtures of experts. Qwen3-Next activates about 3B of its 80B parameters per token, so Janas keeps the experts used most in a cache (21 GiB on the 80B) and reads the rest from the SSD with O_DIRECT, prefetching the next layer's likely experts while the current one computes. When the cache holds under a fifth of the experts, light experts not in memory are skipped altogether, which trades a little accuracy for speed: agreement with llama.cpp's most likely token fell from 393 to 384 of 400 in one of the author's runs. The llama.cpp baseline also needed workarounds to run at all, because its usual build ran out of memory on that laptop, so part of the gap measures llama.cpp's memory appetite rather than raw speed.

Independent evidence is real but partial. Testers have run the 80B on machines with about 31 GiB of RAM at 9.5 to 16.2 tok/s without drafts, which confirms that it works. Nobody has reproduced the 26.4-against-3.0 comparison. The best outside head-to-head, on an i9-14900HX with 62.5 GiB, found llama.cpp faster on Qwen3-30B (38.9 against 28.3 tok/s), the two tied on the 80B, which fitted in RAM there, and Janas ahead on the 142 GB Qwen3-235B (3.0 against 1.59). On a Ryzen 5 5500 without AVX-VNNI, llama.cpp read prompts more than twice as fast.

The costs show up in latency and stability. The first reply of a session runs at 16-20 tok/s while experts still come from disk, a 32,000-token prompt took 15 minutes to read, and the README warns the engine can push a desktop into swap and once caused a GPU driver reset. GPU support is Vulkan only, and open issues report garbage output on an Intel Arc B580 and 3,320 of 3,980 GPU product tests failing on an AMD Radeon. The streaming itself is reads: by the README the engine writes only to ~/.cache/janas, so SSD wear is not the concern; disk bandwidth and heat are, and the project publishes no endurance figure.

The largest risk is governance. All 90 commits are the author's, and CONTRIBUTING.md says no outside code will be merged until a non-profit foundation to hold the copyright exists, so ARM64, macOS and AVX-512 pull requests sit open. Against llama.cpp, with its 132,000-odd stars and every hardware backend, Janas is a narrow tool that wins in one situation: a mixture-of-experts model too big for your RAM, on x86-64.

Where it earns its place

A developer with a 32 GB Linux or Windows laptop and an NVMe drive
Run Qwen3-Next-80B or Qwen3-Coder-Next locally instead of a 30B model
Download the release, run janas-get to fetch the 48.4 GB pre-converted file, then janas-chat. Testers on machines with about 31 GiB report 9.5 to 16.2 tok/s without drafts; expect slower first replies while the expert cache fills, and close the browser, since other programs take memory the cache needs.
A researcher with a 64 GB workstation
Try a 142 GB Qwen3-235B model without buying more RAM
Convert the Q4_K_M GGUF with gguf2jns and let the expert cache take the free memory. One tester measured 3.0 tok/s writing, about twice llama.cpp's mmap result on the same machine: usable for batch questions, too slow for interactive chat.
An engineering lead at a small firm weighing it for an internal assistant
Decide whether a local OpenAI-compatible endpoint on Janas is safe to depend on
janas-server serves one request at a time on 127.0.0.1:8080 with an optional API key, so it fits a single user, not a team. GPL-3.0 allows internal use over HTTP freely, but linking libjanas_llm into software you distribute makes that software GPL; with one maintainer and weekly interface changes, budget for re-testing on every upgrade.

Before you commit

Setup: Prebuilt tarball for Linux x86-64 (Ubuntu 22.04, Debian 12 and later) or a zip for Windows 10 and 11; janas-get lists models, downloads and checks them. Building from source needs only GCC, plus Vulkan headers and glslang 15.2 or later for the GPU. Time to first reply is mostly the model download.
Integrations: janas-server follows OpenAI's API (chat, completions, Responses, embeddings, batches) with a test page; janas-mcp offers the model to Claude Code and other MCP clients; a C library with FreeBASIC and Node.js bindings. GPU through Vulkan 1.3 only; Intel's NPU on Linux Meteor Lake only.
Data and privacy: Runs locally and writes only to ~/.cache/janas and wherever you put converted models; no telemetry is described. The server binds to 127.0.0.1 with no API key by default. GPL-3.0 or later for the code; converted models keep their own licences (Qwen's Apache 2.0, Qwen3.8-Flash-Next's Qwen Community License, DeepNSM's non-commercial CC BY-NC-SA).
Cost at scale: No paid edition, so the cost is hardware: the reference machine is a 32 GB laptop with an NVMe SSD reading about 5.7 GB/s, and slower disks or a busy machine lower speed. The server's single-sequence design means scaling to many users means one machine per concurrent user.
Limits: Developed and measured on one laptop; about 21 open issues and pull requests, including wrong GPU output on Intel Arc B580 and AMD Radeon Vega and slow prompts on Windows with NVIDIA. No CUDA, Metal or ROCm back end, no macOS or ARM build, IQ2 and IQ1 GGUF types not supported, and a 32,000-token prompt took 15 minutes on the reference laptop.

What’s good

Runs 48 GB mixture-of-experts models on 32 GB machines, confirmed by outside testers
Pure C, no dependencies; Linux and Windows release builds
Measures its own threads, GPU and NPU split per machine
OpenAI-style server, MCP server and C library included

What’s not

Headline llama.cpp margins are self-reported on one laptop
Single maintainer; outside code cannot be merged yet
Vulkan only, with wrong-output bugs on several GPUs
No macOS or ARM; experimental, with commands changing weekly

Best for

x86-64 users who want a mixture-of-experts model larger than their RAM, such as Qwen3-Next-80B on a 32 GB laptop, and accept experimental software.

Janas alternatives

llama.cpp

Run models locallyC++132k stars

4.8/5

C/C++ engine for running LLMs locally on CPUs, Apple silicon and most GPUs, home of the GGUF model format.

Ollama

Run models locallyGo184k stars

4.6/5

One-command tool for downloading and running open LLMs locally, with a REST API and optional paid cloud models.

llamafile

Run models locallyC++26k stars

3.9/5

Packages an LLM and its runtime into a single executable file that runs on most operating systems without installing anything.

Janas: common questions

Is Janas worth it?: It really does run an 80B model on a 32 GB laptop, but the big margins over llama.cpp are the author's own and the whole thing is one person's experiment. We rate it 3.6 out of 5.
How much does Janas cost?: Free and open source under GPL-3.0 or later. No paid edition.
What are the downsides of Janas?: Headline llama.cpp margins are self-reported on one laptop; single maintainer; outside code cannot be merged yet; vulkan only, with wrong-output bugs on several GPUs; no macOS or ARM; experimental, with commands changing weekly.
Who is Janas best for?: x86-64 users who want a mixture-of-experts model larger than their RAM, such as Qwen3-Next-80B on a 32 GB laptop, and accept experimental software.
How much does Janas cost for a team or in production?: No paid edition, so the cost is hardware: the reference machine is a 32 GB laptop with an NVMe SSD reading about 5.7 GB/s, and slower disks or a busy machine lower speed. The server's single-sequence design means scaling to many users means one machine per concurrent user.
Is Janas safe for company data?: Runs locally and writes only to ~/.cache/janas and wherever you put converted models; no telemetry is described. The server binds to 127.0.0.1 with no API key by default. GPL-3.0 or later for the code; converted models keep their own licences (Qwen's Apache 2.0, Qwen3.8-Flash-Next's Qwen Community License, DeepNSM's non-commercial CC BY-NC-SA).
What are the best Janas alternatives?: The closest alternatives we have reviewed are llama.cpp, Ollama and llamafile.

Answers checked Oct 31, 2026.