A LOCAL-FIRST AI WORKSHOP FOR AUTONOMOUS CODING

selfware

Name: Selfware
Rating: 89 (27 reviews)
Author: Selfware

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

Try it cargo install selfware

No cloud account required. Open source. MIT. v0.2 BETA

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?

By default, none. LLM inference runs locally. 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 code stays on your machine

No uploads, no training data extraction. Your source code never leaves your hardware.

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 deployed 6 agents to fix them — all autonomously.

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"

🏗️ Architect → planning fix across 18 modules

💻 Coder → patching delta bitmask (u16 not u8)

🧪 Tester → generating 47 regression tests

🔍 Reviewer → verifying thread safety

🔒 Security → sanitizing shell construction

🌸 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)

THE SWARM

Six minds. One purpose.

🏗️ 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

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

🔒 Security

Vulnerability scanning, safety audits. Guards the protected groves.

Agents coordinate through shared memory and a task queue. Each runs its own PDVR cycle.

SELFWARE AGENTIC BENCHMARK

Measured. Not promised.

20 autonomous coding scenarios. 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

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, vision analysis, visual regression testing. An autonomous feedback loop that captures, critiques, and iterates — until the design scores above threshold.

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

$ selfware design-loop --threshold 80

[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

54 tools. 6 commands. One binary.

🌊

Multi-Agent Swarm

6 specialized roles — Architect, Coder, Tester, Reviewer, DevOps, Security. Up to 16 concurrent.

$ 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 autonomy levels.

$ selfware chat --level 3

src/safety/

Also: analyze · journal · status · workflow · dashboard · demo

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 THE SWARM 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	✓	—	—	—	✓
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.

Tools

6800+

Tests

Agents

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

Defense contractor

RECENT ACTIVITY

view all →

latest

VLM benchmark: 19 scenarios, 3 models, 6 difficulty levels

Visual language model evaluation suite

recent

Evolution engine: multi-population tournament selection

Recursive self-improvement via fitness-gated mutation

recent

SAB benchmark: 20 scenarios, 27 rounds, 89/100 grand average

Selfware Agentic Benchmark on Qwen3-Coder-Next FP8

GET STARTED

Three commands.
Your workshop is running.

STEP 1

$ cargo install selfware

Install from crates.io. Requires Rust toolchain.

STEP 2

$ selfware init

Setup wizard — choose your LLM endpoint and model.

STEP 3

$ selfware chat

Start coding. Or selfware run <task> for autonomous mode.

Works with any OpenAI-compatible endpoint — Ollama, vLLM, LM Studio, llama.cpp, SGLang. Primary model: Qwen3.5 Coder.

SAFE CONFIG

# ~/.config/selfware/config.toml

[safety]

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

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

autonomy_level = 2 # supervised

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

or the quick path: ollama pull qwen3-coder && cargo install selfware && selfware init

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.

Selfware's multi-agent swarm works the same way. Individual agents follow PDVR cycles. The collective behavior 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 code stays on your machine

Works with local OpenAI-compatible endpoints

Configurable safety boundaries

Point it at a codebase.Watch it think.

Six minds. One purpose.

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

54 tools. 6 commands. One binary.

Multi-Agent Swarm

Evolution Engine

PDVR Cognition

Digital Garden

Frost Recovery

Safety Guardians

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.