New Nibiru 0.9 — first public preview

An AI framework for the thinking stack.

Nibiru is a lightweight framework built on MMVC — Model, Module, View, Controller. Compose AI modules the way you compose code. Talk to it, ship with it, run it locally.

$ pip install nibiru MIT License Runs on CPU & GPU
// Live chat

Talk to Nibiru, right here.

A working playground running the nibiru-base-7B model. No signup. Same interface you'll embed in your app.

MMVC overview nibiru-base-7B
YS
What's the difference between a Module and a Controller in MMVC?
Nibiru

Good question. In MMVC the two are intentionally distinct:

A Module is a unit of intelligence — a model, a tool, a retriever, a planner. It has typed inputs and outputs and is composable. Think of it like a pure function over the model layer.

A Controller is the orchestration layer. It decides which modules run, in what order, and how their outputs flow into the View. Controllers hold no model state; they hold policy.

// A module class Retriever extends Module { public function forward(string $q): array { ... } } // A controller composes modules $ctrl = new Controller($retriever, $planner, $llm);

If you've used MVC, the mental model maps cleanly — we just split “Model” into Model (weights) and Module (capability).

YS
Show me a planner module I can drop in.
Nibiru

Sure — here's ReActPlanner from the standard library. It's about 40 lines, ships with the framework, and works with any chat module:

ReActPlanner
Reason · act · observe loop. Pluggable tool registry. Streams thoughts.
nibiru.std.plan

Want me to wire it to the retriever above?

nibiru-base-7B · 4k context · streaming
send + newline / command
// Architecture

MMVC, in one breath.

Classic MVC separated data, presentation and logic. Modern AI apps need one more boundary — the capability layer. So we added it.

Model

Weights & state

Foundation models, embeddings, fine-tunes. The substrate.

Module

Capabilities

Retrievers, planners, tools, agents. Typed and composable.

View

Surfaces

Chat, voice, IDE, API. How users talk to the system.

Controller

Orchestration

Routing, policy, lifecycle. The conductor, not the orchestra.

Roadmap: MAMVC (Model · AI · Module · View · Controller) lands in 1.0.

CONTROLLER Orchestration VIEW Chat API IDE MODULE Capability plan tool eval rag MODEL Weights & state USER prompt tools context
// Playground

Run it live.

Edit the code, hit Execute, watch the controller dispatch modules, tools and the model. The same loop runs locally when you ship.

idle
agent.py
nibiru · shell
// Code

Ten lines to a working agent.

Modules compose. Controllers orchestrate. Models run wherever you put them — cloud, edge, laptop.

agent.php retriever.php controller.php
php · 13 lines
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
<?php
use Nibiru\{Model, Module, Controller, View};
use Nibiru\Std\{Retriever, ReActPlanner, ChatView};

$model     = Model::load('nibiru-base-7B');
$retriever = new Retriever(index: './docs', k: 5);
$planner   = new ReActPlanner(model: $model, tools: [$retriever]);

$agent = new Controller($planner, view: new ChatView());

// Stream a turn
foreach ($agent->stream('How does MMVC differ from MVC?') as $token) {
    echo $token;
}
M
Typed modules
Inputs, outputs and tools are typed. Composition fails fast, not at runtime.
V
Any view, same agent
Swap ChatView for VoiceView or APIView. The controller doesn't change.
C
Local-first
Same code path runs on your laptop and your inference cluster. No SDK to fork.
// Models

Download & run locally.

Open weights. Quantized variants for every footprint. Verified checksums and signed manifests.

Nibiru Litev0.9.2 · 1.3B params

Edge & mobile. 4-bit quantized. Runs on a laptop CPU at >30 tok/s.

820 MB
Size
4-bit
Quant
8k
Context
SHA-256a1f3…9c2e
Card
Nibiru Prov0.9.2 · 34B params

Production-grade. Multi-GPU and tensor-parallel out of the box.

19 GB
Size
bf16
Quant
128k
Context
SHA-2560c8e…41d7
Card
CLI $ nibiru pull base-7b
Or use the CLI to fetch any variant. Installation guide →