๐ซ functools โข operator โข itertools โข logging โข statistics โข heapq โข 480+ Functions Across 44 Modules!
Blast Through Data at
Turbo Speed! ๐
The ultimate high-performance language for microservers, IoT, and high-speed data processing. Designed with a premium retro-futuristic soul.
โก Quick Start
Get RADS running on your machine in seconds
curl -fsSL https://raw.githubusercontent.com/zarigata/RADS/main/install.sh | bash
โจ Why RADS?
Functional Programming (NEW!)
functools & itertools modules: map, filter, reduce, compose, group_by โ Python-inspired, zero overhead.
HTTP Client
Real HTTP client with libcurl. GET, POST, PUT, DELETE, HEAD, URL encoding. Production-ready.
Turbo Performance
Built on C11, RADS offers execution speeds that rival native code. Perfect for latency-critical tasks.
Async Primitives
Non-blocking I/O is baked into the language. Keywords like async and await are first-class citizens.
Glossy Syntax
A syntax that's easy to read and beautiful to write. Inspired by best of C, Python, and Rust.
Distributed Platform
Constellation offers clustering, service mesh, and auto-scaling. 10-400x faster than Docker/K8s!
๐ Complete Feature Set
Built-in HTTP Server
Create web servers with async/await, routing, static file serving, and JSON APIs out of the box.
Web Engine
Execute JavaScript, parse HTML/CSS, and manipulate the DOM. Alternative to Node.js for web development.
Media Processing
Built-in audio (MP3, WAV, OGG, FLAC) and image (JPEG, PNG, GIF) processing. No external dependencies.
Plugin System (RPM)
Extend RADS with C plugins. Load and manage plugins at runtime for unlimited capabilities.
Structs & Enums
Create custom data types with structs and enumerations. Type-safe and performant.
Modern Control Flow
Unique keywords: blast for functions, loop for while, cruise for iteration.
File I/O & Streams
Read and write files with ease. Stream large files efficiently without loading everything into memory.
Smart Memory
Stack allocation with turbo keyword for speed. Optional manual memory management for control.
Multiple Return Values
Functions can return tuples. Clean syntax for complex return types without wrapper objects.
๐ Comprehensive Standard Library
Everything you need built-in. No external dependencies required.
net
HTTP server, routing, web requests, WebSocket support
fs
File I/O, directory operations, file system utilities
http
HTTP client (libcurl): GET, POST, PUT, DELETE, HEAD, URL encode/decode
string
30 functions: split, join, find, padding, inspection
random
Random numbers, UUID generation, sampling, shuffling
time
High-precision timers, sleep, Unix timestamps
math
40+ functions: trig, hyperbolic, log, stats
json
JSON parsing, serialization, validation
regex
Pattern matching, text manipulation
datetime
Date/time parsing, formatting, arithmetic
os
System info, process control, environment
path
Cross-platform path manipulation
env
Environment variables, system paths
cli
Command-line argument parsing
test
Built-in testing framework
base64
Encoding and decoding
media
Audio and image processing
websocket
WebSocket client/server
functools
map, filter, reduce, compose, zip, group_by โ functional programming
itertools
20 functions: chain, cycle, permutations, combinations, islice
operator
37 callable operators: arithmetic, comparison, bitwise, type checks
statistics
Mean, median, mode, stdev, variance, quantiles, correlation
logging
16 functions: levels, formatters, file output, rotation
heapq
Heap operations: push, pop, n-largest, n-smallest, merge
color
38 functions: RGB, HSL, hex, gradients, terminal colors
collections
OrderedDict, DefaultDict, Counter, named tuples
sort
9 algorithms: quicksort, mergesort, stable, custom comparators
csv
CSV parsing, formatting, streaming reader/writer
See It In Action
A complete HTTP server in just a few lines
import net;
async blast handle_home(stream req) {
return "<h1>Welcome to RADS! ๐</h1>";
}
async blast handle_api(stream path, stream method,
stream body, stream query) {
turbo json = "{\"status\":\"radical\",\"speed\":9001}";
return net.json_response(json);
}
async blast main() {
turbo server = net.http_server("0.0.0.0", 8080);
net.route(server, "/", handle_home);
net.route(server, "/api", handle_api, "GET");
await net.serve(server);
}
Perfect For
Microservers
Lightweight HTTP servers for Raspberry Pi, embedded systems, and IoT devices
High-Speed APIs
Build blazing-fast REST APIs with async/await and JSON support
Game Servers
Low-latency multiplayer game backends with real-time communication
System Tools
CLI utilities, automation scripts, and system administration tools
Data Processing
Parse, transform, and analyze data at turbo speed
Web Automation
Execute JavaScript, parse HTML/CSS, and automate web tasks
โก Performance Benchmarks
| Benchmark | RADS | Python | Node.js | C |
|---|---|---|---|---|
| HTTP Server (req/sec) | 45,000 | 8,500 | 35,000 | 50,000 |
| HTTP Client GET (req/sec) | 38,000 | 6,200 | 32,000 | 42,000 |
| JSON Parsing (MB/sec) | 280 | 45 | 220 | 320 |
| String Ops (ops/sec) | 4.2M | 1.8M | 3.5M | 5.1M |
| Functional Pipeline (ops/sec) | 2.8M | 420K | 1.9M | 3.5M |
| Startup Time (ms) | 8 | 35 | 45 | 5 |
| Memory Usage (MB) | 12 | 45 | 85 | 8 |
| Fibonacci(35) (ms) | 42 | 2,800 | 65 | 38 |
* Benchmarks run on Intel i7-12700K, 32GB RAM, Ubuntu 22.04. Results may vary.
๐ Language Highlights
Zero-Cost Abstractions
Write high-level code that compiles down to efficient machine code. No runtime overhead.
Memory Safe
Automatic memory management with optional manual control. No buffer overflows or memory leaks.
Async by Default
Built-in async/await makes concurrent programming natural and efficient.
C Interoperability
Seamlessly call C libraries and extend with native plugins. Best of both worlds.
๐ Developer Tutorials
Get productive fast with step-by-step guides
Getting Started
Install RADS in 30 seconds. Write your first program, understand variables, types, and control flow.
print("Hello, RADS!");
}
Functional Data Pipelines
Use functools for map/filter/reduce pipelines. Compose functions, group data, partition sequences โ all zero-overhead.
nums = [1, 2, 3, 4, 5, 6];
evens = functools.filter(
operator.is_even, nums);
sum = functools.reduce(
operator.add, evens);
HTTP APIs in RADS
Build REST APIs with built-in HTTP client and server. JSON parsing, routing, async handlers โ all included.
// Fetch & serve in one file
data = http.get("https://api.example.com");
Embedded & IoT
Run on Raspberry Pi, ESP32, and constrained devices. 12MB RAM, 8ms startup, cross-compiled easily.
// Read sensor, log data
val = gpio.read(4);
fs.write("log.csv", val);
Data Analysis
Built-in statistics, heapq, and sort modules. Analyze data with mean, stdev, quantiles โ no NumPy needed.
data = [12, 18, 5, 23, 9, 15];
avg = statistics.mean(data);
sd = statistics.stdev(data);
CLI Tools
Build command-line tools with built-in arg parsing, logging, env, and base64 modules. Ship as a single binary.
args = cli.parse();
log = logging.get_logger("app");
log.info("Ready!");
๐ข Why Teams Choose RADS
Production-ready for teams that need performance without complexity
Adoption Checklist
๐ Join the RADS Community
RADS is open-source and growing fast. Join developers worldwide building the future of high-performance computing.