Windjammer Programming Language
Write simple code. Run it fast. Debug it easily.
Potencialize seu agente
Instalação do publicador. Não é um endpoint do PlugMCP.
Host a copy with our keys and logs.
Ainda não há uma versão empacotada no registro. Siga o README do repositório.
URL remota ou um comando na sua máquina? Como as duas instalações diferem
Rodar no PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
AbrirDo publicador
Windjammer: a high-level language that compiles to Rust with inferred ownership and explainable decisions. Run the same source instantly in an interpreter, or ship it as Rust, Go, JavaScript or WebAssembly. Built for humans and coding agents (JSON diagnostics, MCP server, llms.txt).
A high-level programming language that combines Go's ergonomics with Rust's safety and performance—plus world-class IDE support.
🎯 The 80/20 Language: 80% of Rust's power with 20% of the complexity
🛠️ Production-Ready Tooling: Complete LSP, debugging, and editor integration
📊 Read the detailed comparison: Windjammer vs Rust vs Go
Windjammer is a pragmatic systems programming language that compiles to Rust, JavaScript, and WebAssembly, giving you:
✅ Memory safety without garbage collection
✅ Rust-level performance (99%+ measured)
✅ Multi-target compilation - Rust, JavaScript (ES2020+), WebAssembly
✅ 276x faster compilation with incremental builds
✅ Automatic ownership inference - no manual borrowing
✅ Go-style concurrency - familiar go keyword and channels
✅ Modern syntax - string interpolation, pipe operator, pattern matching
✅ 100% Rust compatibility - use any Rust crate
✅ World-class IDE support - LSP, debugging, refactoring in VSCode/Vim/IntelliJ
✅ AI-powered development - MCP server for Claude, ChatGPT code assistance
✅ Production-ready - comprehensive testing, fuzzing, security audit (A+ rating)
✅ No lock-in - wj eject converts your project to pure Rust anytime
Perfect for: Web APIs, CLI tools, microservices, data processing, learning systems programming
Philosophy: Provide 80% of developers with 80% of Rust's power while eliminating 80% of its complexity.
# macOS / Linux
brew install windjammer
# Or via Cargo
cargo install windjammer
# Or from source
git clone https://github.com/jeffreyfriedman/windjammer.git
cd windjammer
cargo build --release
./target/release/wj --version
Create hello.wj:
fn main() {
let name = "World"
println!("Hello, ${name}!") // String interpolation!
}
Run it:
wj run hello.wj
use std::http
fn main() {
let server = http::Server::new()
server.get("/", |req| {
http::Response::ok("Hello from Windjammer!")
})
server.get("/user/:name", |req| {
let name = req.param("name")
http::Response::ok("Hello, ${name}!")
})
println!("Server running on http://localhost:3000")
server.listen(3000)
}
Windjammer infers ownership and lifetimes automatically:
// No lifetime annotations needed!
fn longest(s1: str, s2: str) -> str {
if s1.len() > s2.len() { s1 } else { s2 }
}
Compiles to safe Rust:
fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
if s1.len() > s2.len() { s1 } else { s2 }
}
fn main() {
let ch = chan::new()
go {
ch.send("Hello from goroutine!")
}
let msg = ch.recv()
println!(msg)
}
# Compile to native binary
wj build --target=rust
# Compile to JavaScript (Node.js or browser)
wj build --target=javascript
# Compile to WebAssembly
wj build --target=wasm
// String interpolation
let name = "Windjammer"
println!("Hello, ${name}!")
// Pipe operator
let result = data
|> parse()
|> validate()
|> process()
// Pattern matching with guards
match value {
Some(x) if x > 0 => println!("Positive: ${x}")
Some(x) => println!("Non-positive: ${x}")
None => println!("No value")
}
// Defer statement
fn read_file(path: str) -> Result<String, Error> {
let file = fs::open(path)?
defer file.close()
file.read_to_string()
}
Language Server Protocol (LSP):
MCP Server (AI Integration):
Not sure if Windjammer is right for you? No problem!
wj eject
Converts your entire project to pure Rust:
Cargo.toml with dependenciesrustfmt, validated with clippy?Compilation Speed:
Runtime Performance:
Windjammer compiles through multiple stages:
.wj file → Lexer → Parser → Analyzer → Optimizer → Codegen → Target Code
↓
15 Optimization Phases:
1-10: Analysis & transformation
11: String interning
12: Dead code elimination
13: Loop optimization
14: Escape analysis
15: SIMD vectorization
Targets:
Current Version: 0.38.6
Status: Production-ready for early adopters
What's Complete:
What's Next:
wj doc)Windjammer libraries (like windjammer-runtime) are published to crates.io and can be used directly in Rust projects!
The Windjammer runtime provides essential functionality that Windjammer programs depend on:
[dependencies]
windjammer-runtime = "0.37"
use windjammer_runtime::http::Server;
fn main() {
let server = Server::new("127.0.0.1:8080");
server.route("/", |_req| {
"Hello from Rust using Windjammer runtime!"
});
server.listen();
}
Windjammer's standard library modules compile to idiomatic Rust code:
// Windjammer code
use std::http
fn main() {
let server = http::Server::new("127.0.0.1:8080")
server.route("/", fn(req) {
"Hello World"
})
server.listen()
}
Compiles to Rust that you can use in any Rust project:
wj build myapp.wj --target rust
# Generates: build/myapp.rs
[dependencies]
windjammer-ui = "0.3"
use windjammer_ui::components::{Button, Container, Text};
use windjammer_ui::core::Style;
fn main() {
let app = Container::new()
.child(Text::new("Hello from Rust!").render())
.child(
Button::new("Click me")
.on_click(|| println!("Clicked!"))
.render()
)
.style(Style::new().padding("16px"))
.render();
// Render to desktop, web, or mobile
windjammer_ui::run(app);
}
See windjammer-ui documentation for more details.
See the examples/ directory for more:
Dual-licensed under MIT OR Apache-2.0
Created by Jeffrey Friedman and contributors.
Inspiration:
Made with ❤️ by developers who believe programming should be both safe AND simple.
Windjammer: a high-level language that compiles to Rust with inferred ownership and explainable decisions. Run the same source instantly in an interpreter, or ship it as Rust, Go, JavaScript or WebAss
Visão geral
Windjammer: a high-level language that compiles to Rust with inferred ownership and explainable decisions. Run the same source instantly in an interpreter, or ship it as Rust, Go, JavaScript or WebAssembly. Built for humans and coding agents (JSON diagnostics, MCP server, llms.txt).
Ferramentas
Ainda não há lista de ferramentas. Servidores remotos recebem uma após a primeira verificação de saúde.
Perguntas frequentes
Copie nesta página a configuração stdio para Cursor, Claude Desktop, Claude Code ou VS Code. Ela usa a instalação do publicador, não um proxy do PlugMCP.
Este registro não lista nenhuma variável de ambiente obrigatória.
Windjammer roda localmente via stdio.
Última verificação: 2026-11-05. Windjammer: a high-level language that compiles to Rust with inferred ownership and explainable decisions. Run the same source instantly in an interpreter, or ship it as Rust, Go, JavaScript or WebAssembly. Built for humans and coding agents (JSON diagnostics, MCP server, llms.txt).