One API Library.
Every Language. Every Platform.

import io.etherflow.core.Mono;
import io.etherflow.client.WebClient;
import io.etherflow.server.netty.NettyServer;
import io.etherflow.web.function.*;

// 1. Call API reactively using EtherFlow WebClient
WebClient client = WebClient.builder().baseUrl("https://api.etherflow.io").build();
Mono<User> userMono = client.get()
        .uri("/users/1")
        .retrieve()
        .bodyToMono(User.class);

userMono.subscribe(user -> System.out.println("Loaded: " + user.getName()));

// 2. Expose endpoint on Netty Server
RouterFunction routes = RouterFunction.route()
        .GET("/users/{id}", req -> Mono.just(ServerResponse.ok("{\"status\":\"active\"}")))
        .build();
NettyServer.create(8080, routes).start();

import io.etherflow.client.kmp.HttpClient
import io.etherflow.core.Mono

// Kotlin Multiplatform API Call (JVM, Android, iOS, JS)
val client = HttpClient {
    baseUrl("https://api.etherflow.io")
}

suspend fun loadUser(): User {
    // Non-blocking typed GET call
    return client.get("/users/1").executeAs<User>()
}

// Bi-directional WebSocket session
client.webSocket("wss://echo.etherflow.io") {
    send("Hello EtherFlow!")
    incoming.collect { frame -> println("Received: ${frame.text}") }
}

import asyncio
from etherflow import WebClient, NettyServer, Router

# 1. Non-blocking Reactive API Client in Python
client = WebClient(base_url="https://api.etherflow.io")

async def fetch_user():
    user = await client.get("/users/1").to_mono()
    print(f"Loaded: {user['name']}")

# 2. Lightweight Reactive HTTP Server
router = Router().get("/users/{id}", lambda req: {"status": "active"})
NettyServer.create(port=8080, routes=router).start()

using System;
using EtherFlow.Client;
using EtherFlow.Server;

// 1. Reactive API Client in C# / .NET 8
var client = new EtherFlowClient("https://api.etherflow.io");
var user = await client.GetAsync<User>("/users/1");
Console.WriteLine($"Loaded: {user.Name}");

// 2. Functional Server Routing
var router = Router.Create()
    .Get("/users/{id}", req => ServerResponse.Ok(new { status = "active" }));
await NettyServer.ListenAsync(8080, router);

import io.etherflow.client.EtherFlowClient;
import io.etherflow.core.Mono;
import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;

// Android Java Activity API Call
public class MainActivity extends AppCompatActivity {
    private EtherFlowClient client = new EtherFlowClient("https://api.etherflow.io");

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        
        // Non-blocking API GET request on Android Java
        client.get("/users/1")
            .retrieve()
            .bodyToMono(User.class)
            .subscribe(user -> {
                runOnUiThread(() -> showUser(user));
            }, error -> {
                Log.e("EtherFlow", "Android Java API Error", error);
            });
    }
}

import io.etherflow.client.kmp.HttpClient
import io.etherflow.client.compose.produceHttpState
import androidx.compose.runtime.Composable
import androidx.compose.material3.Text

// Jetpack Compose & Android Kotlin Integration
val client = HttpClient {
    baseUrl("https://api.etherflow.io")
}

@Composable
fun UserProfileScreen(userId: String) {
    // Produce reactive HTTP state in Jetpack Compose
    val userState by produceHttpState {
        client.get("/users/$userId").executeAs<User>()
    }

    when (val state = userState) {
        is HttpState.Success -> Text("Hello ${state.data.name}")
        is HttpState.Loading -> CircularProgressIndicator()
        is HttpState.Error -> Text("Error: ${state.message}")
    }
}

import Foundation
import EtherFlowClient

// Pure Swift Native Async API Client
final class NetworkManager {
    private let client = EtherFlowClient(baseUrl: "https://api.etherflow.io")

    func fetchUserProfile(id: Int) async throws -> User {
        let response = try await client.get(url: "/users/\(id)").execute()
        guard response.isSuccess else {
            throw APIError.serverError(response.statusCode)
        }
        return try JSONDecoder().decode(User.self, from: response.data)
    }

    func streamVideoChunks(path: String) async throws {
        let stream = try await client.get(url: path).stream()
        for try await chunk in stream.chunks {
            print("Received chunk: \(chunk.count) bytes")
        }
    }
}

import SwiftUI
import EtherFlowClient

// 1. SwiftUI ViewModel State Manager
@MainActor
class UserProfileViewModel: ObservableObject {
    @Published var user: User? = nil
    @Published var isLoading = false
    private let client = EtherFlowClient(baseUrl: "https://api.etherflow.io")

    func loadUserProfile(userId: Int) {
        isLoading = true
        Task {
            do {
                let response = try await client.get(url: "/users/\(userId)").execute()
                if response.isSuccess {
                    self.user = try JSONDecoder().decode(User.self, from: response.data)
                }
            } catch { print(error.localizedDescription) }
            self.isLoading = false
        }
    }
}

// 2. SwiftUI View Screen Component
struct UserProfileView: View {
    @StateObject private var viewModel = UserProfileViewModel()
    let userId: Int

    var body: some View {
        VStack {
            if viewModel.isLoading {
                ProgressView("Loading Profile...")
            } else if let user = viewModel.user {
                Text(user.name).font(.title).bold()
                Text(user.email).font(.subheadline).foregroundColor(.secondary)
            }
        }
        .onAppear { viewModel.loadUserProfile(userId: userId) }
    }
}

import { EtherFlowClient } from 'etherflow-client';

// Call API in Node.js or Web Browser
const client = new EtherFlowClient({ baseUrl: 'https://api.etherflow.io' });

// Reactive stream subscription
client.get<User>('/users/1')
  .subscribe({
    next: (user) => console.log('User:', user.name),
    error: (err) => console.error('API Error:', err)
  });

import 'package:etherflow_client/etherflow_client.dart';

final client = EtherFlowClient(baseUrl: 'https://api.etherflow.io');

Future<void> fetchUser() async {
  // Non-blocking Reactive API Call in Flutter
  final user = await client.get('/users/1').asMono<User>();
  print('Loaded: ${user.name}');

  // Stream chunked video bytes
  client.stream('/video/chunked').listen((chunk) {
    print('Received ${chunk.length} bytes');
  });
}