A LOCAL-FIRST AI WORKSHOP FOR AUTONOMOUS CODING

selfware

Name: Selfware
Author: Selfware

Run it on your own hardware. Keep your code private. Improve your software with safety rails.

Try it Install selfware

No cloud account required. Open source. MIT. v0.9.7

Just want the install steps? Skip to Quick Start ↓

"Try it" runs in a 15-min sandboxed container on our server, currently backed by DeepSeek V4 Flash via OpenRouter while our GPU is busy. The CLI itself is local-first — install it to keep everything on your hardware.

Selfware chat interface showing ASCII banner, token stats, and command prompt

↓ SCROLL ↓

YOUR CODE STAYS ON YOUR MACHINE · YOUR DATA NEVER LEAVES · EMERGENCE IS NOT ENTROPY · CONSTRAINTS ARE PHYSICS · FITNESS IS SACRED · SOFTWARE THAT LASTS · OWN YOUR INTELLIGENCE · BREAK THE API LEASH · CHARITY FOR PRIVACY · YOUR CODE STAYS ON YOUR MACHINE · YOUR DATA NEVER LEAVES · EMERGENCE IS NOT ENTROPY · CONSTRAINTS ARE PHYSICS · FITNESS IS SACRED · SOFTWARE THAT LASTS · OWN YOUR INTELLIGENCE · BREAK THE API LEASH · CHARITY FOR PRIVACY ·

WHAT WE BELIEVE

Intelligence should be owned, not rented.

Every API call is a dependency. Every subscription is a leash. Every cloud model is someone else's computer reading your code. Selfware is the anti-singularity measure: intelligence that runs on your hardware, improves your software, and answers to no one.

We're building toward a public-benefit structure — self-hosted tools that keep capability in the hands of individuals and small teams. Preserve privacy. Resist centralization-by-convenience.

✓ No API keys ✓ No telemetry ✓ No subscription ✓ No cloud dependency

What data leaves my machine?

Out of the box, your prompts and the code the agent reads go to our free hosted model at llm.selfware.design — that is how it works with zero setup. Point endpoint at Ollama, vLLM or llama.cpp and nothing leaves your machine. Web tools and HTTP calls are explicit opt-in, shown in logs.

♥ Sponsor Support this work →

WHY LOCAL-FIRST

Cloud AI is convenient.
That convenience has a cost.

Every cloud model centralizes power, data, and capability. Selfware is built for personal sovereignty: you own the runtime, your context, and your tools.

AI Misdirection in 2025

Why privacy preservation matters — and what the industry gets wrong.

Your model, your machine

Run inference on your own GPU and your source code never leaves your hardware. No uploads, no training data extraction. The hosted default is there for when you don't have one.

Works with local OpenAI-compatible endpoints

Ollama, vLLM, LM Studio, llama.cpp. Bring your own model, run it your way.

Configurable safety boundaries

Path allow/deny, command filtering, autonomy levels. You decide what it can and can't do.

SEE IT WORK

Point it at a codebase.
Watch it think.

Selfware analyzed a 42,000-line game server, found 3 critical bugs, and fixed them in a single autonomous run.

No prompting. No hand-holding. Just selfware run and a task description.

$ selfware analyze ./massive_game_server

🔍 Scanning 133 Rust files (42,596 lines)...

⚠ Found 3 critical issues:

1. Delta bitmask truncation → silent data loss

2. ObjectPool race condition → memory exhaustion

3. SMS command injection → RCE vulnerability

📊 Doc coverage: 0.8% — needs 20%+

$ selfware run "fix critical bugs, add tests"

🔧 Patching delta bitmask (u16 not u8)

🔧 Fixing ObjectPool race with a mutex guard

🔧 Sanitizing shell construction in SMS handler

🧪 Generating 47 regression tests

🌸 BLOOM — all 3 critical bugs fixed. 47 tests pass.

$ selfware garden

🌱 massive_game_server

├── 🌸 core/ BLOOM (healthy)

├── 🌿 network/ GROW (improving)

├── 🌾 state_sync/ WILT (needs care)

└── ❄️ auth/ FROST (critical)

SWARM ROADMAP

Four roles today. Two on the roadmap.

🏗️ Architect

Module design, refactoring, dependency mapping. Plans the structure before anyone writes a line.

💻 Coder

Implementation and feature development. Writes the code that passes the Tester's scrutiny.

🧪 Tester

Test generation, verification gates. Every mutation must survive the test suite.

🔍 Reviewer

Code review, quality checks. Catches what the Coder missed and the Tester didn't cover.

⚙️ DevOps

Planned. Build pipelines, deployment, infrastructure. Keeps the workshop running.

🔒 Security

Planned. Vulnerability scanning, safety audits. Guards the protected groves.

Today selfware multi-chat sends one task to Architect, Coder, Tester and Reviewer in parallel and lines up their answers side by side — one model call each, no tools yet. More roles join mid-session with /add. Tool-using workers are the next milestone.

SELFWARE AGENTIC BENCHMARK

Measured. Not promised.

12 scenarios scored in the current benchmark round. Easy to Expert. 27 rounds, 323 runs. Real Rust projects, real compilation, real test suites.

89/100

Grand average

90/100

Steady-state

22/27

BLOOM rounds

Perfect streak

S TIER 99-100

calculator, string_ops, json_merge, perf_opt, codegen

Reliability: 100%

A TIER 86-96

bitset, scheduler, event_bus, async_race

Reliability: 89-96%

B TIER 63-72

security, testgen, refactor

Reliability: 74%

calculator

Easy

string_ops

Easy

json_merge

Med

bitset

Med

testgen

Med

refactor

Med

scheduler

Hard

event_bus

Hard

security

Hard

perf_opt

Hard

codegen

Hard

async_race

Expert

svg_chart

Easy

ascii_table

Easy

histogram

E-Med

sparkline

E-Med

progress_bar

Med

maze_gen

Med

unsafe_scan

Hard

actor_pdvr

Hard

First 12 (through async_race) are the scored SAB round above. The remaining 8 are newer scenarios not yet included in a scored run.

PHASE TRANSITIONS — HOW WE GOT HERE

❄️Round 10/5 tests

→+ gateCompletion gate

🌸Round 26/6 pass, 97/100

→+ detectNo-op + repetition detector

🌸Round 5Rescues infinite loops

Small constraint changes → large emergent behavior shifts.

27 rounds on Qwen3-Coder-Next FP8. No cherry-picking. Full run logs on GitHub.

VISUAL LANGUAGE MODEL BENCHMARK

It sees TUIs. It reads flamegraphs.
It writes layouts from mockups.

19 scenarios across 6 difficulty levels. Three models tested on real hardware. PNG fixtures generated from TUI screenshots.

LEVEL	Qwen3.5-9B	Qwen3-VL-30B	Qwen3.5-35B
L1 TUI State Easy	88% BLOOM	62% GROW	50% WILT
L2 Diagnostics Medium	39% WILT	67% GROW	67% GROW
L3 Architecture Hard	30% WILT	47% GROW	63% BLOOM
L4 Profiling VeryHard	100% BLOOM	100% BLOOM	100% BLOOM
L5 Layout Extreme	85% BLOOM	100% BLOOM	100% BLOOM
Mega Evolution Mega	53% BLOOM	33% WILT	76% BLOOM
Overall	66% BLOOM	68% BLOOM	76% BLOOM

Qwen3.5-9B Q8

RTX 4090

17.9K tokens118s

Qwen3-VL-30B FP8

2× RTX 4090

38.7K tokens486s

Qwen3.5-35B Q8

M2 Max 96GB

60.5K tokens3,186s

TUI State

Terminal recognition

Diagnostics

Compiler error parsing

Architecture

Diagram comprehension

Profiling

Flamegraph analysis

Layout

Mockup → ratatui code

Mega

Evolution

Multi-image scoring

All 3 models hit 100% BLOOM on L4 Profiling. The 35B model was first to pass Hard threshold (60%) on L3 Architecture.

See the vision demos →

WOLFRAM'S FOUR CLASSES

How selfware
manages complexity.

Static output. No adaptation, no learning. Dead ends.

Rigid patterns. Maximum order, zero flexibility. Traditional CI/CD falls here.

Unconstrained LLM output — hallucinations, inconsistent logic, no guardrails.

Structured creativity. PDVR cognition + safety constraints = adaptable but controlled.

↑ Toggle phases. Watch the hero particles respond.

PHASE TRANSITION MAP

—

Flat

entropy: ~0

∿

Repetitive

entropy: low

⚡

Chaotic

entropy: max

✦

Complex

entropy: med

✦ Complexity ≠ entropy. Organized complexity — structure with surprise.

PLAN

VERIFY

REFLECT

PDVR
CYCLE

TWO LOOPS, NESTED

Two feedback
loops.

Inner loop: PDVR cognitive cycle. Working memory tracks hypotheses. Episodic memory persists across sessions.

Outer loop: Evolution Engine evaluates proposed changes against test suites and fitness benchmarks. Only improvements that pass all gates are kept.

BLOOM FROST

COMPOSITE FITNESS FUNCTION

SAB

Tokens

Latency

SAB Score 50% Token Efficiency 25% Latency 15% Coverage 5% Binary Size 5%

VISUAL INTELLIGENCE

It can see.

Screenshot capture works today. Vision analysis and regression diffs are experimental, and the scored design loop is a roadmap preview of where they are going.

selfware dashboard

┌─ AGENTS ────────┬─ OUTPUT LOG ──────────┐
│ ● Architect  ✓ │ [14:23] Scanning 133..  │
│ ● Coder      ■ │ [14:24] Found 3 issues  │
│ ● Tester     ● │ [14:24] Patching...     │
│ ● Reviewer   · │ [14:25]Tests pass ✓    │
├─────────────────┼────────────────────────┤
│ STATUS: 4/6 active   │  MEM: 142MB       │
└─────────────────┴────────────────────────┘agent_list
output_log
status_bar

VLM Response — structured JSON

{
  "panels": [
    { "name": "agent_list",
      "bounds": [1,1,16,5] },
    { "name": "output_log",
      "bounds": [18,1,38,5] },
    { "name": "status_bar",
      "bounds": [1,7,38,7] }
  ],
  "indicators": {
    "active": 4,
    "icons": ["✓","■","●","·"]
  },
  "accessibility": {
    "contrast": 4.8,
    "box_drawing": true
  }
}

rustc output

error[E0382]: borrow of moved value: `data`
  --> src/sync/buffer.rs:47:18
   |
45 |     let data = vec![1, 2, 3];
   |         ---- move occurs because `data`
   |              has type `Vec<i32>`
46 |     process(data);
   |             ---- value moved here
47 |     println!("{:?}", data);
   |                      ^^^^ value borrowed
   |                           here after move
   |
help: consider cloning the value
   |
46 |     process(data.clone());
   |                 ++++++++

Structured Extraction

{
  "error_code": "E0382",
  "error_type": "borrow_after_move",
  "location": {
    "file": "src/sync/buffer.rs",
    "line": 47, "col": 18
  },
  "moved_at": { "line": 46 },
  "suggestion": {
    "action": "clone",
    "insert": ".clone()"
  },
  "confidence": 0.97
}

AFTER

┌─ Dashboard ──────────────────┐
│ Agents     │ Task Queue     │
│ ● Arch     │ fix: delta      │
│ ● Code    ┃ test: buffer     │
│ ● Test     │ rev: auth       │
├──────────────────────────────┤
│ Status: OK│Mem: 142MB     │
└──────────────────────────────────┘

BEFORE

┌─ Dashboard ──────────────────┐
│ Agents    │ Task Queue      │
│ ● Arch    │ fix: delta       │
│ ● Code    │ test: buffer     │
│ ● Test    │ rev: auth        │
├───────────┼──────────────────┤
│ Status: OK │ Mem: 142MB      │
└───────────┴──────────────────┘

◂▸

vision_compare output

pixel_similarity: 73.2%
semantic_diffs: 3
  1. Sidebar border: "│" → "┃" (line 4, col 13)
  2. Row join: "┼" → "─" (line 6, col 12)
  3. Status row: column divider removed (line 7)
verdict: "regression_detected"

design loop · roadmap preview

# preview: illustrates the planned loop, not a shipped command

[iter 1] Capturing screenshot...

[iter 1] Analyzing — score: 59/100

[iter 1] Below threshold. Applying 4 fixes...

[iter 2] Capturing screenshot...

[iter 2] Analyzing — score: 72/100

[iter 2] Below threshold. Applying 2 fixes...

[iter 3] Capturing screenshot...

[iter 3] Analyzing — score: 82/100

[iter 3] ✓ Threshold met — design approved

Visual Critic Scores

Composition82

Hierarchy78

Readability91

Overall: 82/100 THRESHOLD: 80 ✓

Iter 1

4 fixes

Iter 2

2 fixes

Iter 3

✓ done

screen_capture

Screenshot any screen, window, or region

browser_screenshot

Headless Chrome/Playwright full-page capture

vision_analyze

Send to any VLM for structured analysis

vision_compare

Pixel + semantic visual regression testing

CONSTRAINTS ARE PHYSICS

Fitness is sacred.

Entropy is removing constraints. Organized complexity is adding the right constraints.

IMMUTABLE INVARIANTS

✗Cannot modify its own fitness function

✗Cannot modify the benchmark suite

✗Cannot modify the safety module

✗All mutations must pass cargo check

✗Property tests mandatory for core mutations

PROTECTED GROVES

🛡️ src/evolution/

🛡️ src/safety/

🛡️ system_tests/

🛡️ benches/sab_

The evaluator cannot be modified by the thing being evaluated.

SAFETY RAILS

What it can't do matters
as much as what it can.

Path allow/deny

File access is gated by configurable path rules. No wildcard defaults.

Command filtering

Dangerous commands (rm -rf, sudo, etc.) are blocked unless explicitly allowed.

Protected invariants

Safety modules, fitness functions, and evaluation code are immutable. The system cannot modify its own guardrails.

KNOWN LIMITATIONS ▾

•LLM outputs are non-deterministic — same input may produce different results

•Safety boundaries are advisory when autonomy level is set to maximum

•No formal verification of generated code — tests are the safety net

Full security policy → SECURITY.md

SELFWARE DOCTOR — SYSTEM DIAGNOSTICS

Selfware doctor command showing system diagnostics — Rust tools, Python tools, security checks, container tools

selfware doctor audits your toolchain, security posture, and dependencies before you start.

YOUR TOOLKIT

90+ tools. One binary.

🌊

Swarm Roadmap

Architect, Coder, Tester and Reviewer answer the same task in parallel for side-by-side comparison; add roles with /add. Tool-using workers are the next milestone.

$ selfware multi-chat

src/orchestration/

🧬

Evolution Engine

LLM proposes edits to its own source. Compile, test, evaluate fitness. Only BLOOMs survive.

$ selfware evolve

src/evolution/

🔄

PDVR Cognition

Plan → Do → Verify → Reflect. Working memory + episodic memory across sessions.

$ selfware run <task>

src/cognitive/

🌱

Digital Garden

Files as plants with growth stages. selfware garden visualizes codebase health.

$ selfware garden ./src

src/ui/garden.rs

❄️

Frost Recovery

Checkpoint seeds survive crashes. Resume any session from last known state.

$ selfware resume

src/session/checkpoint.rs

🛡️

Safety Guardians

Path validation, command filtering, SSRF protection, symlink guards. 4 execution modes, from ask-first to yolo.

$ selfware -m auto-edit chat

src/safety/

📖

Grounded Review

Reads the whole repo before it answers. On selfware's own ~320-file core: 100% of lines read in 1.37 h, 162 citations checked, 0 wrong. Runs out of budget? It says ⚠️ PARTIAL and lists what it skipped.

$ selfware review .

CHANGELOG

📐

Proved in Lean

The agent loop, review pipeline, completion gate, path safety and evolution bounds are modelled in Lean and checked against the Rust code in CI. The proofs found six real bugs.

$ lake build

formal/

🔐

Trust Boundaries

Clone something you didn't write and its git hooks, filters and config-level programs never run. Repo-local hooks, MCP servers and safety overrides wait for an explicit trust.

$ selfware trust

src/safety/

Also: analyze · garden · journal · status · workflow · dashboard · mcp · llm-doctor

WHAT IT LOOKS LIKE

selfware dashboard

Chat, garden, tools, and logs in one view

selfware chat

Interactive coding with token tracking

command palette

30+ commands at your fingertips

BATTLE-TESTED

42,000 lines of Rust.
One command.

A real-time multiplayer game server — WebRTC networking, SIMD physics, 16-agent AI, FlatBuffers protocol. Selfware scanned it, found critical vulnerabilities, and proposed fixes.

133

Rust files

42.6K

Lines of code

Critical bugs found

Modules refactored

BUGS FOUND AUTONOMOUSLY

Delta bitmask truncation

u16 cast to u8 — shields and flags silently lost

CRITICAL

ObjectPool race condition

TOCTOU on max size — unbounded memory growth

CRITICAL

Shell command injection

Unsanitized SMS command construction — RCE vector

CRITICAL

WHAT SELFWARE DID

✓Split 1,787-line monolith into 18 focused modules

✓Generated regression tests for each critical fix

✓Mapped all 40+ undocumented environment variables

✓Identified O(N²) bot AI bottleneck with spatial index fix

✓Flagged join-throughput collapse at 73+ concurrent clients

Selfware identified these issues and proposed fixes. Human review was applied before merging. View the project →

🦊

Be first to know when v1.0 ships.

Changelog drops, hardware guides, and community builds. One email when it matters.

✓ Subscribed!

HOW IT COMPARES

The only tool that owns its own loop.

When local LLMs are good enough — why rent intelligence?

	Selfware	Cursor	Copilot	Aider	SWE-Agent
Runs locally	✓	—	—	✓	✓
Self-improving	✓	—	—	—	—
Multi-agent (roadmap)	◐	—	—	—	✓
Visual agent	✓	—	—	—	—
Your data stays local	✓	—	—	✓	✓
No subscription	✓	—	—	✓	✓
Any LLM backend	✓	—	—	✓	—
Evolution engine	✓	—	—	—	—
Codebase health viz	✓	—	—	—	—
Agentic benchmark	✓	—	—	—	✓

CLOUD AI

Cursor Pro$240/yr

Copilot Business$228/yr

API credits$600+/yr

Your dataleaves

$600–1,000+/year

LOCAL (RTX 4090)

GPU (one-time)~$1,600

Electricity~$55/yr

Selfware$0 (MIT)

Your datastays

~$55/yrafter GPU

150W × 8h/day × $0.12/kWh. GPU amortized over 5 years = $320/yr. Still cheaper than cloud year 1.

90+

Tools

12k+

Tests

100%

Repo Read in Review

515+

Commits

90/100

SAB Score

EARLY ADOPTERS

What builders are saying.

From early testers during private beta.

"Pointed it at our 30K-line monolith. It found a race condition we'd missed for months. In minutes."

Systems engineer

Game server team

"The evolution engine is unlike anything else. Watching it improve its own code is wild."

ML researcher

University lab

"Finally, AI coding that doesn't phone home. Our security team signed off in a day."

Staff engineer

Enterprise software team

RECENT ACTIVITY

view all →

latest

v0.9.6: parallel review reads 100% of a repo, 0 wrong citations

~320 files in 1.37 h (0.9.4: 59% in 3.9 h). Review pipeline proved in Lean

recent

v0.9.5: security release for untrusted repositories

Repo git hooks and filters never run; read-only really means read-only

recent

v0.8: zero-config start on the free hosted endpoint

No API key, no local GPU needed to try it. Bring your own model any time

GET STARTED

Three commands.
Your workshop is running.

STEP 1

$ cargo install selfware

From crates.io. No Rust? Signed binaries for Linux, macOS and Windows.

STEP 2

$ selfware chat

Works with zero config on our free hosted model. No API key. Or selfware run <task> for autonomous mode.

STEP 3

$ selfware init

Optional. Point it at your own model and nothing leaves your machine.

Works with any OpenAI-compatible endpoint — Ollama, vLLM, LM Studio, llama.cpp, SGLang. Hosted default: qwen38-flash-next. Locally, Qwen3.5 — sized to your GPU below.

SAFE CONFIG

# ~/.config/selfware/config.toml

endpoint = "http://localhost:11434/v1" # your model

execution_mode = "normal" # ask before writes

[safety]

allowed_paths = ["./src/**", "./tests/**"]

denied_paths = ["./secrets/**", ".env"]

Start with least-privilege paths. Widen as you build trust.

CAN I RUN IT?

If you have a GPU, you're ready.

ENTRY

RTX 4060 Ti (16 GB)

Qwen3.5 9B Q4

Context: 16-32K

Everyday coding, moderate tasks

Apple: Mac 24 GB

SWEET SPOT

RECOMMENDED

RTX 4090 / 3090 (24 GB)

Qwen3.5 27B Q4

Context: 32-64K

Full SAB scenarios, multi-agent

Apple: Mac 64 GB

PRODUCTION

RTX 5090 (32 GB) / H100

Qwen3.5 35B-A3B Q4

Context: 64-128K

Best value. Full evolution engine.

Apple: Mac 96-128 GB

Ollama vLLM llama.cpp LM Studio MLX SGLang

Any OpenAI-compatible endpoint. No API keys to cloud services needed.

BEGIN

$ cargo install selfware && selfware chat

fully local: ollama run qwen3.5:4b && selfware init · prebuilt binaries

MIT licensed. Linux, macOS, Windows.
Your hardware. Your data. Your loop.

AT THE EDGE OF CHAOS

Simple rules. Iterated.
Until structure appears.

Conway's Game of Life — three rules, infinite complexity. Nobody designs the gliders or the oscillators. They emerge.

That is the bet behind selfware's swarm roadmap: small, verified loops, composed. The behavior we want is a property of the system, not any single agent.

GAME OF LIFE — NEW · MATURE

Click 'reseed' · Watch order emerge

OPEN SOURCE

Built in the open. Join the loop.

Selfware is MIT licensed. Contributions, bug reports, and ideas are welcome.

🐛

Report a bug

Found something? Open an issue.

🔀

Submit a PR

Code, docs, tests — all welcome.

💬

Discussions

Ideas, questions, show & tell.

Join the inner loop.

Evolution logs, benchmark drops, hardware guides. The signal, not the noise.

✓ Subscribed!

No spam. Stored locally on this server. Your data never leaves.

selfware

Intelligence should be owned, not rented.

Cloud AI is convenient.That convenience has a cost.

Your model, your machine

Works with local OpenAI-compatible endpoints

Configurable safety boundaries

Point it at a codebase.Watch it think.

Four roles today. Two on the roadmap.

Measured. Not promised.

It sees TUIs. It reads flamegraphs.It writes layouts from mockups.

How selfwaremanages complexity.

Two feedbackloops.

It can see.

Fitness is sacred.

What it can't do mattersas much as what it can.

Path allow/deny

Command filtering

Protected invariants

90+ tools. One binary.

Swarm Roadmap

Evolution Engine

PDVR Cognition

Digital Garden

Frost Recovery

Safety Guardians

Grounded Review

Proved in Lean

Trust Boundaries

42,000 lines of Rust.One command.

The only tool that owns its own loop.

What builders are saying.

Three commands.Your workshop is running.

If you have a GPU, you're ready.

Simple rules. Iterated.Until structure appears.

Built in the open. Join the loop.

Cloud AI is convenient.
That convenience has a cost.

Point it at a codebase.
Watch it think.

It sees TUIs. It reads flamegraphs.
It writes layouts from mockups.

How selfware
manages complexity.

Two feedback
loops.

What it can't do matters
as much as what it can.

42,000 lines of Rust.
One command.

Three commands.
Your workshop is running.

Simple rules. Iterated.
Until structure appears.