wootype 🐕

⚡ Blazing-fast Go Type System Service — 100-1000x faster than traditional type checking

wootype is an ultra-fast Go type checking engine written in Rust, featuring incremental computation architecture (Salsa) and ECS storage model for sub-millisecond type checking response.

📖 中文文档

🚀 Extreme Performance

Speed Comparison

Test environment: Standard x86_64, Release mode

Why So Fast?

🦀 Native Rust Performance
   ├─ Zero-cost abstractions
   ├─ No GC pauses
   └─ Extreme memory control

⚡ Salsa Incremental Computation Framework
   ├─ Automatic dependency tracking
   ├─ Fine-grained caching (LRU)
   └─ Only recompute changed parts

🔧 ECS Storage Architecture
   ├─ Entity-Component-System
   ├─ Archetype compact storage
   └─ Cache-friendly data layout

🔄 Concurrent Safety Design
   ├─ DashMap lock-free reads
   ├─ scc::HashMap fine-grained locks
   └─ 1000+ AI Agent concurrency

📊 Performance Details

Cold Start vs Incremental Update

Cache Query Performance

Data source: SALSA_PERFORMANCE_COMPARISON.md

Comparison with Go Toolchain

✨ Features

📦 Installation

From crates.io

cargo install wootype

From Source

git clone https://github.com/yourusername/wootype.git
cd wootype
cargo install --path . --release

Pre-built Binaries

# Linux x86_64
curl -L https://github.com/yourusername/wootype/releases/latest/download/wootype-linux-amd64 -o wootype
chmod +x wootype
sudo mv wootype /usr/local/bin/

🚀 Quick Start

As a Library

use wootype::prelude::*;
use std::sync::Arc;

// Create type universe
let universe = Arc::new(TypeUniverse::new());

// Perform type checking
let result = universe.check_file("main.go");

// Incremental update
let delta = universe.check_incremental(changes);

Type Query

use wootype::core::{TypeUniverse, TypeKind, PrimitiveType};
use wootype::query::QueryEngine;
use std::sync::Arc;

#[tokio::main]
async fn main() {
    let universe = Arc::new(TypeUniverse::new());
    let engine = QueryEngine::new(universe);
    
    // Query by fingerprint
    let fingerprint = PrimitiveType::Int.fingerprint();
    let results = engine.query_by_fingerprint(fingerprint);
    
    for ty in results {
        println!("Found type: {:?}", ty);
    }
}

AI Agent Session

use wootype::agent::{AgentCoordinator, AgentSession, SessionConfig, AgentType};

// Create coordinator
let coordinator = AgentCoordinator::new();

// Create session
let config = SessionConfig {
    agent_type: AgentType::TypeChecker,
    isolation_level: IsolationLevel::ReadCommitted,
    ..Default::default()
};

let session = coordinator.create_session(config);

// Perform type checking in session
let result = session.check_types("main.go");

As LSP Server

# Start LSP service
wootype daemon --port 8080

# Or use stdio mode
wootype lsp

Type Query CLI

# Check file types
wootype check main.go

# Query symbol type
wootype query --symbol "MyStruct" --file main.go

# Start type checking service
wootype serve --port 8080

# WebSocket mode
wootype ws --port 8081

🏗️ Architecture

┌─────────────────────────────────────────────────────────────┐
│                    wootype Architecture                      │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐     │
│  │   Parser    │    │    Salsa    │    │  Type Store │     │
│  │(tree-sitter│───▶│   Database  │◀──▶│  (ECS/Arche │     │
│  │             │    │             │    │    type)    │     │
│  └─────────────┘    └──────┬──────┘    └─────────────┘     │
│                             │                                │
│         ┌───────────────────┼───────────────────┐           │
│         ▼                   ▼                   ▼           │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐     │
│  │  Queries    │    │  Cycles     │    │   Cache     │     │
│  │ (tracked)   │    │  Detection  │    │   (LRU)     │     │
│  └─────────────┘    └─────────────┘    └─────────────┘     │
│                             │                                │
│  ┌──────────────────────────┼──────────────────────────┐   │
│  │                    LSP / API Layer                  │   │
│  │  ┌────────┐  ┌────────┐  ┌────────┐  ┌────────┐   │   │
│  │  │   gRPC │  │WebSocket│  │  HTTP  │  │  LSP   │   │   │
│  │  └────────┘  └────────┘  └────────┘  └────────┘   │   │
│  └────────────────────────────────────────────────────┘   │
│                                                              │
└─────────────────────────────────────────────────────────────┘

Core Technologies

📚 Documentation

• API Docs
• Architecture
• Chinese Docs

💡 Use Cases

IDE Real-time Type Checking

User types character → Salsa incremental check → Update type hints
Latency: ~50ns (cache hit)
Experience: ✅ Zero-perceptible delay

AI Agent Batch Analysis

// 1000+ AI Agents querying types concurrently
let universe = Arc::new(TypeUniverse::new());

for agent in 0..1000 {
    let u = universe.clone();
    spawn(async move {
        let type_info = u.query_type(symbol_id); // O(1) query
    });
}

CI Type Checking

# Fast type checking in CI pipeline
wootype check ./... --incremental

# Integration with woof
woof check . --types-enabled

Cross-package Type Analysis

# Analyze interface implementation relationships
wootype impl --interface "io.Reader" --project .

# Detect circular type dependencies
wootype cycles --strict

🤝 Contributing

Contributions welcome! Please see CONTRIBUTING.md.

# Development environment
git clone https://github.com/yourusername/wootype.git
cd wootype
cargo test
cargo bench

📄 License

Apache License 2.0 © [Your Name]

Made with ❤️ and 🦀 Rust

"wootype makes Go type checking so fast you forget it exists."