52,000+ RPS Performance

Blazing Fast
Python Web Framework

Combine the simplicity of Python with the raw performance of Rust. Build high-performance APIs with FastAPI-style syntax.

Get Started
pip install sufast

FastAPI Syntax

Familiar decorator-based routing with @app.get() and @app.post()

Rust Performance

Rust-powered core delivers 52,000+ requests per second

Easy to Use

Simple installation and intuitive API for rapid development

Features

Why Choose Sufast?

Experience the perfect blend of Python's simplicity and Rust's performance

Performance
Rust-Powered Performance
Built on a Rust core for maximum speed and efficiency. Handle 52,000+ requests per second with minimal resource usage.
Developer Experience
FastAPI-Style Syntax
Familiar decorator-based routing with @app.get(), @app.post(), and more. Easy migration from FastAPI projects.
Reliability
Type Safety
Full Python type hints support with automatic validation and serialization for robust API development.
Simplicity
Zero Configuration
Get started immediately with sensible defaults. No complex setup or configuration files required.
Standards
Modern Standards
Built-in support for CORS, middleware, async/await, and modern web standards out of the box.
Efficiency
Low Memory Footprint
Efficient memory usage with Rust's zero-cost abstractions. Perfect for containerized deployments.
Quick Start

Get Started in Minutes

Create your first high-performance API with just a few lines of code

1. Install Sufast
Install via pip with pre-compiled Rust binaries
pip install sufast
2. Create Your App
Write your first API endpoint
from sufast import App

app = App()

@app.get("/")
def hello():
    return {"message": "Hello from Sufast ๐Ÿ‘‹"}

app.run()
3. Run & Test
Start your server and test the endpoint
python app.py
# Visit http://localhost:8080
Advanced Example
Build a complete API with multiple endpoints
Complete API Examplepython
from sufast import App

app = App()

# Sample data
users = {
    "1": {"name": "Alice", "email": "alice@example.com"},
    "2": {"name": "Bob", "email": "bob@example.com"}
}

@app.get("/")
def home():
    return {"message": "Welcome to Sufast API ๐Ÿš€"}

@app.get("/users")
def get_users():
    return {"users": list(users.values())}

@app.get("/users/{user_id}")
def get_user(user_id: str):
    if user_id in users:
        return {"user": users[user_id]}
    return {"error": "User not found"}, 404

@app.post("/users")
def create_user():
    return {"message": "User created"}, 201

app.run()
Performance Benchmarks

Real-World Performance

See how Sufast compares to other popular web frameworks in production scenarios

Framework Comparison
Comprehensive benchmark results across key performance metrics
FrameworkLanguage
RPS
Latency (ms)
Memory (MB)
Startup (ms)Developer UX
๐Ÿฆ€ Native Rust (Actix-Web)๐Ÿฆ€ Rust
56,000+๐Ÿ”ฅ
~1.7~20~25โš ๏ธ Manual, low-level routing
๐Ÿš€ Sufast (Rust + Python)
Sufast
๐Ÿฆ€ Rust + ๐Ÿ Python
52,000+๐Ÿ”ฅ
~2.1~25~35โœ… FastAPI-style, intuitive
๐Ÿ FastAPI (Uvicorn)๐Ÿ Python
25,000+
~5.6~60~90โœ… Very Dev-Friendly
๐ŸŒ Node.js (Express)JavaScript
35,000+
~4.2~50~40โœ… Dev-Friendly
52,000+
Requests per second

Near-native Rust performance with Python convenience

2.1ms
Average latency

Lightning-fast response times for better user experience

25MB
Memory usage

Efficient memory footprint perfect for containers