Tako v.0.5.0 road to v.1.0.0

Tako added SIMD-accelerated JSON (≈24% higher RPS on heavy payloads), a route-level plugin system (compression, CORS, rate limiting), and first-class Async‑GraphQL (HTTP + subscriptions), alongside routing/DX upgrades like matchit paths, TSR redirects, fallbacks, handler macros, and Responder for anyhow::Result. Realtime and media support expanded with WebSockets, SSE, file streaming, Range and JWT extractors, plus TLS. A live OpenAPI stochastic simulation demo runs on Tako: https://stochastic-api-production.up.railway.app/.

Async Rust Mutexes vs. Lock-Free

We benchmark std::Mutex, parking_lot::Mutex, tokio::Mutex, and two lock-free counters on the same async workload. Spoiler: a single hot atomic isn’t king—batched/sharded approaches and short, await-free critical sections often win. When to use what, why it matters, and how not to summon cache-line demons.

stochastic-rs: High-Performance Stochastic Process Simulation in Rust

stochastic-rs is a high‑performance Rust crate for simulating stochastic processes—especially fractional/“rough” models—aimed at quant finance and research. It leverages SIMD, Rayon, jemalloc, and experimental CUDA to accelerate path generation, and includes diffusions, jump and volatility models, SDE solvers, calibration and option‑pricing tools, plus a fast fBM via the Davies–Harte method. The roadmap targets Metal support, copulas, enhanced sensitivity/Malliavin tools, and Python bindings.

🦀 Scientific Computing Benchmark: Rust 🦀 vs Zig ⚡ vs the father C 👴

This benchmark compares Rust, Zig, and C for generating Ornstein–Uhlenbeck stochastic processes. Despite my limited Zig and C experience, Rust came out surprisingly fast, highlighting its strong ergonomics and performance for scientific computing right out of the box.

Tako: A Lightweight Async Web Framework on Tokio and Hyper

Tako is a lightweight async web framework built on Tokio and Hyper, offering explicit regex-based routing, simple middleware, and an extensible plugin system. It delivers high performance with a clean API plus extras like SSE/WebSocket support and strongly-typed request extractors. Still in an early stage, it’s promising for lean services but should be adopted cautiously in production.

Deploying Rust App – Part 1: Going Serverless with Google Cloud Run

Kick off your Rust deployment journey by taking your app live with Google Cloud Run. In this first part of the series, we’ll containerize a simple Actix Web app and deploy it to a serverless platform with autoscaling, zero cold starts, and pay-as-you-go pricing.

Switch to a Rust Backend Without Giving Up WebSocket and Subscription Benefits for Heavy SQL Queries

We migrated a critical subscription feature from Hasura to a custom Rust backend to overcome SQL performance bottlenecks. Using async-graphql, field-level caching, and SIMD-powered JSON parsing, we drastically improved response times. The result? Happier users, faster startup, lower server costs — and yes, Rust was worth every second.

CUDA Programming in Rust: Extending Fractional Noise Generation for AI Models

This post explores integrating CUDA with Rust to accelerate fractional Gaussian noise (fGn) generation in the stochastic-rs library. It covers the CUDA implementation, Rust FFI integration, and performance benefits for large-scale stochastic simulations.

Why Your Company Needs Rust Experts – And How We Can Help

Rust is revolutionizing software development with its speed, memory safety, and efficiency. We help companies build, optimize, and successfully adopt Rust-based systems. If you need fast, reliable, and scalable solutions, get in touch with us!

Our First Production-Ready RAG Dev Journey in Pure Rust

Within a month, we built a Rust-based RAG system capable of reliably handling information from multilingual PDF files. Despite various technical challenges (like PDF processing, GPU setups, and Python integration), the final result delivers 85–90% accurate, hallucination-free answers in an industrial setting.

iTransformer implementation in pure Rust

iTransformer is a novel deep learning architecture for multivariate time series forecasting, focusing on inter-variate relationships instead of sequential token dependencies. Implemented in Rust, it leverages high performance and memory safety to deliver scalable and efficient forecasting solutions.

Rust 2024 Wrap-Up: Biggest Changes and Future Outlook

In 2024, Rust grew a lot in many areas. The 1.75 release improved async features, const generics, and tooling, making Rust simpler and faster. Developers built new libraries for AI, embedded, WebAssembly, and games, proving Rust’s safety and performance. By the end of the year, Rust was widely seen as a production-ready choice for many real-world projects.

Inline Assembly in Rust

In this blog post, we explore how inline assembly in Rust provides direct hardware access and performance optimizations by combining low-level CPU instructions with Rust’s safe programming features.

The Power of Bitwise Operations

We explore the use of bitwise operations to solve Day 7 of Advent of Code 2024 in Rust. By leveraging these operations, we achieved exceptional performance compared to traditional iterator-based and parallelized solutions.

Boost Flutter App Performance with Rust

Learn how to integrate Rust into your Flutter projects for faster performance, smooth data handling, and access to Rust libraries. Compare tools like flutter_rust_bridge and rinf, follow a simple step-by-step guide, and explore real-world examples. Perfect for developers seeking high-performance cross-platform apps!

Creating a State Manager for React with Rust and WebAssembly

Using Rust and WebAssembly to build a state manager for React showcases the potential of Wasm in web development, providing safe, high-performance state management directly in the browser. While there is some overhead from serialization, this approach highlights how Wasm can handle complex tasks efficiently, paving the way for more performant alternatives to JavaScript frameworks.

Deep Learning the Volatility Surface: An AI-Enhanced Calibration of the Heston Model

In this post, we've demonstrated how deep learning can enhance the calibration of the Heston model by approximating the implied volatility surface using a neural network. The method significantly reduces computational time while maintaining accuracy, addressing the challenges in traditional calibration methods. By integrating the neural network approximation into the calibration process, we achieve a balance between efficiency and precision, paving the way for more advanced applications in quantitative finance.

Calibrate Option Price under the Heston model using Rust

This post introduces the calibration of the Heston model, a popular option pricing model that extends the Black-Scholes-Merton framework by incorporating stochastic volatility. By aligning model parameters with observed market prices, the Heston model provides a more accurate representation of market dynamics.

Async Rust Explained - Pinning - Part 2

Pinning in Rust ensures that a value's memory address remains constant, preventing it from being moved. This is crucial for self-referential structures and asynchronous tasks, especially in async runtimes like Tokio, where futures might be moved across threads. By using Pin, Unpin, and PhantomPinned, developers can safely handle data that relies on stable memory locations, maintaining both performance and safety in advanced Rust programs.

Async Rust Explained - Part 1

Async programming in Rust can seem intimidating at first, but with the right mindset, it's possible to understand it in a simple way. This series will guide you through Async Rust, step by step, so you can gain confidence in writing concurrent applications without sacrificing safety.

Building a Rust library for DHT11 sensor: A Step-by-Step Guide

In this blog article, we'll provide a step-by-step guide on how to write your own Rust library for an embedded sensor. We've chosen the DHT11 sensor due to their simplicity and ease of understanding. The library will be built using only embedded-hal.

Hack Rust's Type System with Union Types

Union types in Rust allow you to store multiple types at the same memory location, providing flexibility and potential performance optimizations, but require unsafe blocks for access. This post explores using union types to return either a single value or a vector, showcasing a powerful yet risky way to bypass Rust's strict type system.

Speed up my financial mathetmatics crates in Rust

This project focused on optimizing the performance of a fractional Brownian motion generator in Rust. By refining algorithms, parallelizing key operations, and adjusting compiler settings, significant efficiency improvements were achieved. Leveraging Rust’s strengths in memory management and system-level control allowed the code to run more efficiently, demonstrating the language’s potential for high-performance computing tasks.

Building a Simple LED and Button Interface with Rust on ESP32

In this continuation of our journey into embedded systems with Rust on the ESP32, we'll enhance our previous LED project by introducing button control. Building upon the foundational concepts covered earlier, we'll explore how to read input from a button and use it to manipulate an LED's state.

Building a Rust Native Module for React Native on iOS and Android

We detailed how to integrate Rust with React Native for both iOS and Android, focusing on setting up the environment, configuring libraries, and building Rust modules. We discussed the advantages of using Rust for better performance and safety in mobile app development. The guide also emphasized React Native's strengths in delivering native UI/UX and its recent improvements with the JavaScript Interface (JSI) that reduce overhead, making it a highly efficient cross-platform framework.

Introduction to Embedded Systems with Rust: A Beginner's Guide Using ESP32

This guide introduces developers with basic Rust knowledge to the world of embedded systems, focusing on the ESP32 microcontroller. It covers fundamental hardware and software concepts, including setting up the development environment, executing a "Hello World" program, and flashing an LED, all while using Rust's no_std environment.

Building a Modern Dating App Backend with Rust, Async-GraphQL, SurrealDB, and WebSocket

Building a backend for a modern dating app using Rust, Async-GraphQL, SurrealDB, and WebSocket involves integrating these technologies to manage data, handle real-time communication, and create a scalable infrastructure. The post provides practical examples of key operations like sending, updating, and deleting messages, showcasing how these tools work together effectively.

Estimating Parameters of the Fractional Ornstein-Uhlenbeck (fOU) Process using LSTM in Rust

This Rust code demonstrates how to estimate parameters of the fractional Ornstein-Uhlenbeck (fOU) process using Long Short-Term Memory (LSTM) neural networks. It leverages the stochastic-rs library to generate synthetic data for the fOU process and the candle library to build, train, and evaluate the LSTM model. The code is designed for high-performance simulations and efficient neural network computations, making it suitable for use in fields like quantitative finance and physics.

Welcome to our Rust Blog

Welcome to our new blog dedicated to exploring Rust's capabilities, featuring tutorials, insights, and discussions.