comparisonlocal-llmcognisocmullamallamafuzigllm

Mullama vs Llamafu vs ZigLLM: The cognisoc Family in 2026

Mullama vs Llamafu vs ZigLLM compared: the three public cognisoc runtimes in 2026 — Rust production, Dart mobile, Zig educational. One per language, one per surface.

Published June 29, 2026 · Updated June 29, 2026 · By Local LLM Team

Mullama vs Llamafu vs ZigLLM: the cognisoc family in 2026

cognisoc is the open-source team behind local-llm.net. The three public runtimes are Mullama (desktop / server, production), Llamafu (mobile, production), and ZigLLM (educational). This page compares them and helps you pick which one to use.

Overview

MullamaLlamafuZigLLM
LanguageRust + 5 native bindingsDart (Flutter)Zig
Target surfacedesktop, server, embedded appsAndroid, iOSeducational, research
First release2025-082025-082025-09
Stars (Jun 2026)126
Maturityv1.x stablev1.x mobileeducational
Foundationllama.cpp (Rust bindings)llama.cpp (FFI)from-scratch in Zig
Model formatGGUFGGUFGGUF (loader) + own tensors
Native bindings6 (Rust, Python, Node, Go, PHP, C)1 (Dart)0
OpenAI API✓✗ (local API in v2)✗
Anthropic API✓✗✗
Vision✓✓partial (LLM only)
Audio✓✗✗
Production-ready✓✓ (mobile)✗
LicenseMITMITMIT
Websitemullama.cognisoc.comllamafu.cognisoc.comzigllm.cognisoc.com
GitHubcognisoc/mullamacognisoc/llamafucognisoc/zigllm

When to use each

Choose Mullama when…

  • You are deploying a desktop or server LLM and want a Rust-first runtime.
  • You need native bindings for 6 languages (Rust, Python, Node, Go, PHP, C).
  • You want a drop-in Ollama replacement (same CLI, same Modelfile, same port 11434).
  • You need OpenAI + Anthropic compatible HTTP APIs.
  • You are building an embedded desktop app (Tauri, Electron, etc.) and want the engine in-process.

Choose Llamafu when…

  • You are building a mobile app in Flutter (or native Android / iOS).
  • You need on-device inference with no cloud, no API calls, no data leaving the device.
  • You want function calling, vision, structured JSON in a Flutter package.
  • You are okay with the mobile platform’s constraints (1B-7B models, Q4 quantization).

Choose ZigLLM when…

  • You want to learn how LLMs work by reading the source.
  • You are a researcher implementing a new architecture and want a clean, readable reference.
  • You are teaching a course on transformer internals and need a well-commented codebase.
  • You want a Zig ML library that you can adapt to your own work.
  • Do not use it for production inference. Use llama.cpp or Mullama for that.

Architecture comparison

MullamaLlamafuZigLLM
Memory modelRust ownershipDart FFI + manualmanual (Zig)
GPU offload✓ (CUDA, Metal, ROCm, Vulkan, OpenCL, SYCL, RPC)✓ (Metal, OpenCL, Vulkan)✗ (CPU only)
Quantizationall GGUF formatsall GGUF formatsreads GGUF, owns quantization
ThreadingRust asyncDart isolates + FFI threadsZig threads
Streaming✓✓✓
Hot-reload models✓✓ (mobile pattern)✗

How they share work

All three sit on top of (or alongside) the GGUF model format. A model file you download for Mullama will work in Llamafu and (with limits) in ZigLLM. This means:

  • You can prototype in ZigLLM to understand the math.
  • Run the same model in Llamafu on a phone.
  • Serve the same model with Mullama on a server.
  • All three consume the same GGUF files, no conversion needed.

Performance

Tokens per second, Llama 3.2 1B Q4_K_M, single thread for parity:

RuntimeLinux x86macOS M2Android Pixel 8
Mullama4538n/a
Llamafun/a3211
ZigLLM (educational)1210n/a

Mullama and Llamafu are both production-grade. ZigLLM is 3-4× slower because it is a from-scratch implementation without the optimization layers of llama.cpp.

Code comparison

Mullama (Rust)

use mullama::{Model, Context, ContextParams};

let model = Model::load("llama3.2-1b.gguf")?;
let mut ctx = Context::new(&model, ContextParams::default())?;
let response = ctx.generate("Hello, AI!", 256)?;

Llamafu (Dart)

final llamafu = await Llamafu.init(
  modelPath: '/path/to/llama-3.2-1b-q4_k_m.gguf',
  threads: 4,
);

final result = await llamafu.complete(
  prompt: 'Hello, AI!',
  maxTokens: 256,
);

ZigLLM (Zig)

const llama = @import("llama");
const model = try llama.Model.load("llama3.2-1b.gguf");
const ctx = try model.context(.{});
const response = try ctx.generate("Hello, AI!", 256);

Decision matrix

Your situationUse
Server / desktop productionMullama
Multi-language app (Python + Rust + Node)Mullama
Flutter mobile appLlamafu
Native iOS / AndroidLlamafu (FFI) or MLC LLM
Need OpenAI / Anthropic APIMullama
Vision on mobileLlamafu (LLaVA, Qwen2-VL)
Voice assistant on desktopMullama (built-in audio)
Teaching / researchZigLLM
Building a new architecture prototypeZigLLM
Want to read the source to learnZigLLM
Embedded desktop (Tauri / Electron)Mullama
Web app (WebGPU)MLC LLM, not any of these three

See also

Frequently Asked Questions

Why three runtimes? Why not one?

Each cognisoc runtime targets a different deployment surface and language. Mullama is a production Rust runtime for desktop/server with native bindings for 6 languages. Llamafu is a Flutter FFI plugin for mobile. ZigLLM is an educational Zig implementation. They share a common foundation (llama.cpp) but solve different problems.

Are they all MIT licensed?

Yes, all three are MIT licensed. Commercial use, modification, and redistribution are all permitted.

Which is the most production-ready?

Mullama is the most production-ready (v1.x stable, OpenAI + Anthropic compatible, six native language bindings). Llamafu is production-ready for mobile. ZigLLM is educational — do not use it for production inference.

Can I use the same model across all three?

Yes. Mullama and Llamafu both read GGUF files (the universal format). ZigLLM reads GGUF for inference of pre-trained models. Pick a model on Hugging Face in GGUF format and it will work in all three.