# Mayorana

> Mayorana builds api0: your existing software in Teams, WhatsApp, Telegram and Claude, acting as the person asking. Plus native Rust tools for Azure.

Every page listed here also exists as HTML at the same URL without ".md". The apps are source-available (PolyForm Noncommercial 1.0.0): free for personal, educational and non-profit use; commercial use needs a plan.

## MCP server

- https://mayorana.ch/mcp: a public, read-only MCP server (Streamable HTTP) with the tools search, list_apps, get_app, get_release_notes, get_post, get_learning_path and get_pricing. Claude Code: `claude mcp add --transport http mayorana https://mayorana.ch/mcp`

## Apps

- [AIS Runner](https://mayorana.ch/en/apps/ais-runner.md): Azure Integration Services — local development desktop
- [AIS Monitor](https://mayorana.ch/en/apps/ais-monitor.md): Azure Logic Apps workflow chain explorer
- [AIS Tracing](https://mayorana.ch/en/apps/ais-tracing.md): Correlation-id tracer for Azure Cosmos DB
- [AIS Analytics](https://mayorana.ch/en/apps/ais-analytics.md): Correlation-id tracer for Azure Log Analytics
- [PublishKit](https://mayorana.ch/en/apps/publishkit.md): AI-powered blog post manager with queue-to-publish workflow
- [ShipScreen](https://mayorana.ch/en/apps/shipscreen.md): The complete iOS & Android build and publish assistant
- [GitAgent](https://mayorana.ch/en/apps/gitagent.md): Agentic graph for commit and deploy workflows
- [TrackCut](https://mayorana.ch/en/apps/trackcut.md): Split long MP3/WAV recordings into tracks, from the keyboard
- [SpreadRadar](https://mayorana.ch/en/apps/spreadradar.md): Crypto price gaps across exchanges and Solana, live
- [PolishCast](https://mayorana.ch/en/apps/polishcast.md): Record your screen, get a polished video: smooth cursor, zoom on clicks
- [JobScout](https://mayorana.ch/en/apps/jobscout.md): Job posts from LinkedIn and local boards, ranked against your profile
- [SurfaceWatch](https://mayorana.ch/en/apps/surfacewatch.md): Watch a web app's client-side attack surface change between builds

## Plans

- [Pricing](https://mayorana.ch/en/pricing): a plan unlocks the apps it lists and refills a monthly allowance of AI credits.
- [api0](https://api0.ai): the Rust MCP gateway that puts your existing software into Teams, WhatsApp, Telegram and Claude.

## Blog: Rust, from first principles

- [GC Pauses and Latency: The Hidden Cost of High-Level Languages](https://mayorana.ch/en/blog/why-garbage-collector.md): Java, Python, and JavaScript offer convenience, but garbage collection introduces unpredictable latency. Explore how runtime memory management affects performance in real systems.
- [C Gives You Control, But at What Cost?](https://mayorana.ch/en/blog/c-low-level-cost.md): C avoids garbage collection and gives manual memory control, but opens the door to dangerous bugs. Explore real-world memory issues and why they matter.
- [Rust: Memory Safety Without Garbage Collection](https://mayorana.ch/en/blog/why-rust-memory-safe.md): Rust gives you the performance of C with memory safety enforced at compile time. Learn how ownership and borrowing eliminate entire bug classes.
- [Getting Started with Rust: A Guide for Beginners](https://mayorana.ch/en/blog/getting-started-with-rust.md): Introduction to Rust for beginners, covering installation, basic syntax, and your first project.
- [What is `clamp` in Rust, and when should you use it?](https://mayorana.ch/en/blog/clamp-rust.md): What clamp does, why it panics on a swapped min and max, and how it differs from the saturating arithmetic it gets confused with.
- [How does Rust ensure memory safety without a garbage collector?](https://mayorana.ch/en/blog/memory-safety-rust.md): Ownership, borrowing and lifetimes give Rust memory safety at compile time, with no collector and no runtime pauses to budget for.
- [Stack vs. Heap in Rust: Where Does Your Data Live?](https://mayorana.ch/en/blog/stack-heap-allocation-rust.md): What actually decides whether a value lands on the stack or the heap in Rust, and what each choice costs you at runtime.
- [How does ownership prevent memory leaks and data races?](https://mayorana.ch/en/blog/ownership-safety-rust.md): How the ownership rules close off memory leaks and data races before the program ever runs, and where they stop short.
- [Mutable vs. immutable borrows: the two rules](https://mayorana.ch/en/blog/borrowing-rules-rust.md): The two borrowing rules, why exclusivity is the one that matters, and what the borrow checker actually rejects.
- [How does Rust prevent dangling pointer at compile time?](https://mayorana.ch/en/blog/dangling-pointer-rust.md): Why a dangling pointer is a compile error in Rust rather than a crash in production, and how lifetimes make that check possible.
- [What is &mut *x (reborrow) in Rust, and why does it freeze the original reference?](https://mayorana.ch/en/blog/reborrow-rust.md): A reborrow duplicates the reference, not the data, and freezes the original for its duration. What &mut *x really does.
- [String vs. &str – Which to Use and When?](https://mayorana.ch/en/blog/string-vs-str-rust.md): String vs str in Rust, covering memory management, ownership, and when to use each type.
- [Where do string literals (&str) live?](https://mayorana.ch/en/blog/string-literals-memory-rust.md): String literals live in the binary's read-only data with a 'static lifetime — what that means for allocation, copying, and returning them.
- [Why &str Won't Fit &String in Rust: Fun Fixes for String Mismatches!](https://mayorana.ch/en/blog/string-str-mismatch-rust.md): Why passing a &str where a &String is expected fails to compile, what deref coercion does and doesn't do, and how to fix the mismatch.
- [What is the purpose of Box<T> in Rust?](https://mayorana.ch/en/blog/box-pointer-rust.md): What Box<T> is for, what the extra indirection costs, and when a heap allocation is the right call rather than a reflex.
- [How does Cow<'a, B> (Copy-on-Write) work in Rust?](https://mayorana.ch/en/blog/cow-copy-on-write-rust.md): Cow<'a, B> lets a function borrow when it can and allocate only when it must. How copy-on-write works and when it pays for itself.
- [Understanding the Drop Trait in Rust](https://mayorana.ch/en/blog/drop-trait-rust.md): How the Drop trait works, when the destructor runs, and why implementing it by hand is rarer than it looks.
- [Rust Vec::new() vs. with_capacity(): When to Use Each](https://mayorana.ch/en/blog/vec-new-vs-with-capacity.md): Vec allocation strategies in Rust, comparing Vec::new() and Vec::with_capacity() for optimal performance.
- [What is the difference between Box<[T]> and Vec<T>?](https://mayorana.ch/en/blog/box-slice-vs-vec-differences.md): Comparing Box<[T]> and Vec<T> differences in mutability, memory overhead, and performance implications for different use cases
- [How do into_iter(), iter(), and iter_mut() differ?](https://mayorana.ch/en/blog/iter-methods-rust.md): into_iter(), iter() and iter_mut() differ in what they hand you: the value, a shared reference, or an exclusive one.
- [Implications of iterating over a Vec with .into_iter() instead of .iter()](https://mayorana.ch/en/blog/into-iter-vs-iter-ownership.md): Understanding the differences between .into_iter() and .iter() when iterating over Vec, covering ownership implications and performance considerations
- [Rust Operators & Iterators: Quick Reference](https://mayorana.ch/en/blog/rust-comparison-operators-iterators.md): Essential Rust operators, iterator differences, and Unicode handling you need to know.
- [Rust's collect() Magic: Turning Iterators into Vecs, HashMaps, and Strings!](https://mayorana.ch/en/blog/collect-method-rust.md): How collect() decides what to build, what FromIterator asks of the target type, and how to steer it towards a Vec, a HashMap or a String.
- [How do you remove duplicates from a Vec<T> where T: Eq + Hash?](https://mayorana.ch/en/blog/efficient-duplicate-removal-vec.md): Efficient approaches to remove duplicates from Vec<T> where T: Eq + Hash, comparing HashSet-based and sort-based methods with performance analysis
- [Vec::retain() Vs filtering with iter().filter().collect()?](https://mayorana.ch/en/blog/vec-retain-vs-filter-collect.md): Comparing Vec::retain() in-place filtering with iter().filter().collect() for different filtering scenarios and performance implications
- [Vec::drain() Vs Vec::truncate() or Vec::clear()?](https://mayorana.ch/en/blog/vec-drain-vs-truncate-clear.md): Understanding Vec::drain() functionality and comparing it with Vec::truncate() and Vec::clear() for different element removal scenarios
- [Flatten a Vec<Vec<T>> into a Vec<T> using iterators](https://mayorana.ch/en/blog/flatten-vec-iterators-performance.md): Flattening Vec<Vec<T>> using iterators compared to manual concatenation, analyzing performance implications
- [Rust Traits vs. Java/C# Interfaces: Shared Behavior Done Right](https://mayorana.ch/en/blog/rust-traits-vs-interfaces.md): Discussion on Rust traits vs Java/C# interfaces, covering dispatch mechanisms, compile-time behavior, and performance optimizations.
- [Trait Bounds](https://mayorana.ch/en/blog/trait-bounds-rust.md): Using trait bounds in Rust for type safety and performance in mathematical computations
- [Trait bounds or dyn Trait? Static and dynamic dispatch compared](https://mayorana.ch/en/blog/dispatch-performance-rust.md): Generics with a trait bound compile to static dispatch; dyn Trait compiles to a vtable lookup. What each costs, and how to choose.
- [Making Traits Object-Safe for Rust's dyn Trait in Plugin Systems](https://mayorana.ch/en/blog/object-safety-rust.md): Understanding object safety in Rust and refactoring traits for dynamic dispatch
- [Supertraits: enforcing a hierarchy of behaviours](https://mayorana.ch/en/blog/supertraits-bounds-optimization.md): Leveraging supertraits to establish behavior hierarchies and combining them with where clauses to optimize complex generic algorithms for performance and type safety
- [?Sized: writing one function for both sized and unsized types](https://mayorana.ch/en/blog/sized-unsized-bounds-flexibility.md): Understanding the role of ?Sized bounds in Rust trait definitions and leveraging them to create flexible functions that work with both sized and unsized types efficiently
- [Associated types vs. generics in a low-level I/O driver API](https://mayorana.ch/en/blog/associated-types-io-driver-api.md): Utilizing associated types in Rust traits to design flexible, type-safe APIs for low-level I/O drivers and comparing advantages over generic type parameters
- [Blanket implementations: one impl for every type that qualifies](https://mayorana.ch/en/blog/blanket-implementations-coherence.md): Employing blanket implementations in Rust to minimize code duplication for maintainable libraries
- [Functions or Closures in Rust? Know the Difference!](https://mayorana.ch/en/blog/function-vs-closure-rust.md): Functions vs closures in Rust, covering ownership, traits, lifetimes, and performance implications.
- [What are the differences between Fn, FnMut, and FnOnce?](https://mayorana.ch/en/blog/fn-traits-rust.md): Fn, FnMut and FnOnce aren't traits you pick — the compiler derives them from how the closure uses what it captured.
- [What are move closures (move || { ... })? When are they necessary, and how do they interact with ownership?](https://mayorana.ch/en/blog/move-closures-rust.md): What move actually moves, when you genuinely need it (threads, returned closures, async blocks), and how it interacts with ownership.
- [Understanding Rust Move Closures: A Guide for JavaScript Developers](https://mayorana.ch/en/blog/move-closures-rust-javascript-developers.md): Learn how Rust move closures work compared to JavaScript closures - ownership, threading, and when to use the move keyword
- [How do you specify a closure as a function parameter or return type?](https://mayorana.ch/en/blog/closure-parameter-rust.md): Taking and returning closures: when impl Fn is enough, when you need Box<dyn Fn>, and what each choice costs at the call site.
- [Rust's Stateful Closures: Passing and Mutating Across Multiple Calls](https://mayorana.ch/en/blog/stateful-closures-rust.md): Managing stateful closures in Rust for repeated function calls
- [Rust's Higher-Order Functions: Powering Flexible Closures](https://mayorana.ch/en/blog/higher-order-functions-rust.md): Exploring higher-order functions in Rust for functional programming patterns
- [How do you store a closure in a struct?](https://mayorana.ch/en/blog/storing-closures-in-structs.md): Storing closures in structs using generic parameters, trait objects, and lifetime annotations with Fn, FnMut, and FnOnce bounds
- [How do you handle lifetimes when returning a closure that captures variables from its environment?](https://mayorana.ch/en/blog/handling-lifetimes-returning-closures.md): Managing lifetimes when returning closures that capture variables, covering ownership transfer, lifetime annotations, and avoiding dangling references in Rust
- [impl Fn() vs. Box<dyn Fn()>: Rust's Closure Dispatch Showdown](https://mayorana.ch/en/blog/closure-dispatch-rust.md): Comparing static and dynamic dispatch for closures in Rust, focusing on performance and use cases
- [Using closures versus regular functions ?](https://mayorana.ch/en/blog/closure-performance-overhead-rust.md): Analyzing performance overhead of closures versus regular functions in Rust, covering static dispatch, heap allocation, and optimization scenarios
- [How Rust's Ownership and Borrowing Ensure Safe Concurrency](https://mayorana.ch/en/blog/concurrency-rust.md): Ownership and borrowing rule out data races at compile time. What Send and Sync add, and why Rc can't cross a thread boundary.
- [Deadlocks in C vs Rust: What Does Rust Really Prevent?](https://mayorana.ch/en/blog/deadlocks-c-vs-rust.md): Deadlocks aren't prevented by compilers—but Rust adds safety guarantees that make writing deadlock-prone code harder. Here's how it compares to C.
- [Vec::push() in a loop vs. pre-allocating with Vec::with_capacity()?](https://mayorana.ch/en/blog/vec-push-vs-with-capacity-performance.md): Comparing performance of Vec::push() in loops versus pre-allocating with Vec::with_capacity(), analyzing memory reallocation costs and optimization strategies
- [Zero-Cost Abstractions: How Rust Optimizes Iterator Chains](https://mayorana.ch/en/blog/zero-cost-abstractions-rust.md): Low-level optimization in Rust, focusing on iterator chains and zero-cost abstractions
- [Avoiding heap allocation on a real-time path](https://mayorana.ch/en/blog/allocation-avoidance-real-time-rust.md): Leveraging Rust's stack-based features like fixed-size arrays and Option to eliminate heap allocations in real-time systems for predictable, low-latency execution
- [Rust's repr: Optimize Struct Memory for Cache Efficiency](https://mayorana.ch/en/blog/memory-layout-optimization-rust.md): Low-level memory optimization in Rust, covering repr attributes, cache efficiency, and performance trade-offs
- [Align data structures to cache lines](https://mayorana.ch/en/blog/cache-line-awareness-optimization.md): Designing cache-aligned data structures in multi-threaded Rust applications to prevent false sharing and optimize performance for large dataset processing
- [Boosting Rust Hot Loops: Slashing Branch Mispredictions](https://mayorana.ch/en/blog/branch-prediction-rust.md): Low-level optimization in Rust, focusing on minimizing branch mispredictions in performance-critical loops
- [Instruction-Level Optimization: #[inline(always)]](https://mayorana.ch/en/blog/instruction-level-optimization-inline-always.md): Strategic application of Rust's #[inline(always)] attribute for instruction-level optimization, covering effective usage patterns and risks of overuse
- [SIMD in Rust: Optimizing Matrix Multiplication](https://mayorana.ch/en/blog/simd-matrix-mult-rust.md): Leveraging Rust’s SIMD support for accelerating matrix multiplication with considerations for portability and correctness
- [Mastering Inline Assembly in Rust: When and How to Optimize Safely](https://mayorana.ch/en/blog/inline-assembly-rust.md): Low-level optimization in Rust, focusing on using inline assembly for performance-critical tasks
- [Profiling Rust: Tackling L1 Cache Misses with perf, Flamegraph, and Criterion](https://mayorana.ch/en/blog/profiling-optimization-rust.md): Low-level optimization in Rust, focusing on profiling tools to identify and fix performance bottlenecks like L1 cache misses

## Blog: LLMs from scratch

- [Episode 0: Why Code LLMs From Scratch](https://mayorana.ch/en/blog/llm-from-scratch-introduction.md): Understanding how LLMs work without a PhD in mathematics: what this series promises, what you will learn, and the one idea that ties every episode together.
- [Episode 1: Attention Is Just 4 Mathematical Operations](https://mayorana.ch/en/blog/attention-four-operations.md): Behind Transformers and the attention mechanism there are only four simple operations: matrix multiplication, transposition, scaling and softmax. Here they are, in Rust.
- [Episode 2: Q, K, V — Why 3 Matrices Instead of One?](https://mayorana.ch/en/blog/query-key-value-three-matrices.md): Query, Key, Value: why real models project each word into three different spaces, and what that separation of roles changes for attention.
- [Episode 3: Embeddings — Absolute at the Start, Contextual at the End](https://mayorana.ch/en/blog/embeddings-absolute-vs-contextual.md): Is an embedding the word on its own or the word in context? Both, at different moments. Plus the three engineering details around attention: multi-head, masking and position encoding.
- [Episode 4: Transfer Learning — Strategies and Key Concepts](https://mayorana.ch/en/blog/transfer-learning-reusing-knowledge.md): Why nobody trains a model from zero: where transfer learning comes from, what it saves you, and its three strategies — feature extraction, fine-tuning and LoRA.
- [Episode 5: Embeddings and Vector Databases](https://mayorana.ch/en/blog/embeddings-vector-databases-rag.md): From keywords to meaning: how embeddings and cosine similarity let you search by proximity, why you need a vector database, and how it all comes together as a RAG.

## Blog: Azure integration

- [AIS Runner: A Desktop GUI for Local Azure Logic Apps Standard Development](https://mayorana.ch/en/blog/ais-runner-intro.md): AIS Runner is a Dioxus-based desktop app for local Azure Logic Apps Standard development — manage, run, debug, and compare workflows without leaving your dev environment.
- [Your Logic Apps Are a Graph, and the Azure Portal Only Shows You a List](https://mayorana.ch/en/blog/logic-apps-workflow-chains.md): Past a dozen workflows, an Azure Logic Apps estate stops being a list and becomes a graph connected by Service Bus queues and Event Grid topics. Here is why the portal cannot show you that graph, and what to do about it.
- [Following a Correlation ID Through Log Analytics Without Writing KQL](https://mayorana.ch/en/blog/trace-correlation-id-log-analytics.md): A Log Analytics workspace holds the answer to where your integration flow stopped. Getting it out normally means a KQL query per table and knowing which column ties the steps together. It does not have to.
- [How Far Did That Order Get? Tracing a Correlation ID Across Cosmos DB](https://mayorana.ch/en/blog/trace-correlation-id-cosmos-db.md): A customer says their order never arrived. You have a correlation id and an Azure Cosmos DB account with more containers than anyone remembers. Here is why the empty results matter more than the full ones.

## Blog: Git tooling

- [AI Commit Messages Without Handing Over Your Git History](https://mayorana.ch/en/blog/ai-commit-messages-without-giving-up-control.md): AI git tooling tends to come in two shapes: a text box you copy out of, or an agent that runs commands and tells you afterwards. There is a third option, and it comes down to where the approval sits.

## Optional

- [AI in Companies Isn't 50 Use Cases. It's 3 Things.](https://mayorana.ch/en/blog/three-categories-of-ai-in-companies.md): Most generative and agentic AI projects fit into three categories: agents for customers, integration layers for systems, and copilots for employees. Here is why that lens beats a list of fifty use cases.

## Other languages

- [Français](https://mayorana.ch/fr/llms.txt)