Good morning everyone. My name is Raul Tawa, senior Network Cloud infrastructure engineer at Kyro Technologies based out of Dallas, Texas. Over the past decade, I have led large scale in transformations for the global enterprises, including migrating more than 2000 plus sites to SD-WAN in modernizing manufacturing networks and implementing AI driven routing architectures. Today's session is about. Building Next generation network infrastructure using Rust, a language that has fundamentally changed how we approach a safety performance and concurrency in production networks. We'll explore how Rust enables zero trust packet processing AI based routing decisions and enterprise great security without compromising on the performance. So today's we'll break down the session into five parts. Why Russ, why rusts for the network infrastructure's, real time, real world case studies, practical implementation techniques, security, enterprise options, and key takeaways, and the next steps. The challenge of modern network infrastructure, the problem is pretty clear these days. Our networks are growing faster and more complex than our tools. We are moving from 10 GBPS pipes to 400 GBPS backbones with sub millisecond latency requirements for high frequency trading. 5G core functions and real time analytics recommendations are no longer static. They're being driven by ML models that need real time interference, optimizing for latency, condition jitter, and even energy efficiencies. Meanwhile, in the legacy stack, in such as C and C plus PE, carry, dig of technical debt and security package buffer overflows, dangling binders, race conditions that attackers allowed to exploit. And the operational cost of patching and hardening these systems is growing substantially high. In short, the gap between what the network needs to do and what our current tools allow our current tools allow is widening to large extent why rust is ideal for network infrastructures. Rust solves the pro this problem without forcing us to compromise. The ownership model, memory safety is enforced to compile time without a garbage collector, no runtime overheads, no pauses, and no leaks. This matters in the networks where dropping a packet is not an option. Zero cost abstractions, right code that looks high level, but combines down to machine code as a as efficient as a handwritten code. We can design expressive APIs for packet parsing without adding cycles. Fearless concurrency, rust makes it safe to share state between threads without locks, enabling parallel packet parsing without the race conditions, which is a really great option. Memory safety by eliminating buffer flows and use after free rust removes the root cause or root cause of 70% of CVEs in network software over the last decade in production. This means you can hit line rate performance while guaranteeing safety properties that were once to impossible in the system language. Zero copy packet processing with rust. In traditional stack, a single packet might be copied five times. Nick to kernel user and kernel to user base and the kernel back to the nick. Each copy adds a latency and burn CPU cycles at 400 GVPS. Even a single extra copy can cost millions of hardware over time. With rust, we can eliminate most of it. Map Nick Buffers directly into. User space with safety abstractions. Pass references instead of making memory copies, use borrow. Borrow, checking to guarantee no dangling pointers or double freeze. In integrate with this async runtime like Tokyo for non-blocking packets IO in our tests, moving from traditional copying to rust. Zero copy approach, reduced packet processing latency by 40 to 65%, and free CPU core for additional workloads like telemetry analysis. Let's do a case study, taking the financial services industry through the routing in the financial service industry. This was a, this was for a major US exchange with extreme latency sensitivity security, which is one of the most important. 94% of the vulner vulnerabilities disappeared overnight simply because rust made them representable in code. No more emergency. Midnight patches for the buffer overflows latency. Routing decisions dropped from one 20 milliseconds to 32 milliseconds. That's nearly four times improvement in the HFT. That can be the difference between winning and losing a trade. Throughput, same hardware, 3.4 more transactions per second. No extra networkers. No extra CPUs. AI driven routing in rust. With rust, we can run ML reference directly in the forward path. No round trips to separate analytical engine data collection telemetry at tens of thousands of samples per second, using zero cost obstruction model training offline on historical routing data with features like utilization jitter packet and drops interference. Rust based engines run these models in microseconds. Selecting optical parts in real time, hard swapping hard swap out models without stopping traffic. Enabling adaptive learning network techniques. This makes it possible to have truly self optimized network with decision aware decisions are dynamical dynamic as the traffic itself. Practical roster techniques for network programming. These are the three powerful techniques. Stand out efficient protocol serialization. Using ER for compact zero copy. Serialization de serialization of the routing, routing headers and telemetry data. Custom allocators, pre allocate buffers with predictable latency at 400 GPS and nanosecond matters Ring buffers. LOP free packet queues with atomic index. For deterministic throughput, these patterns let us match and often beat the performance of hand optimized code while keeping rust strong safety guaranteed intact. Security advantage of rust. The majority of the network CVEs come from memory safety issues, exactly what trust eliminates. No buffer overflows, no use of free after free. No data raise. Strong type system prevents logic errors in packet parsing and routing state machines. Even when we do need unsafe blocks for hard hardware access, the rust forces us to isolate and capsulate and audit that code. This drastically reduces the attack surface while keeping performance at a bare metal levels. Let's do a case study of a manufacturing network, resilience in a manufacturing industry. Fortune 500 manufacturer has had a recurring nightmare pro in a production lines Hal halted by the network outages I, and then the recovery time was up to 17 minutes. Gradually gradual performance degradation from memory links was also a ma major issue. After implementing the rust routing he, the manufacturer hit the uptime of 99.998%, and the failover and recovery dropped. Under 200 microseconds milliseconds, security patches applied without taking the network offline via hot patching, and the VP of Operation told that rust and error handling turn our network from a frequent failure point into our most reliable system enterprise adoption strategies. So you don't have to rewrite everything on one day. It's basically starts by by targeting the bottlenecks per safety and performance. I improvement say performance improvements will have the biggest ROI. Use FFI Bridges to integrate rust models with c cc plus legacy systems run parallel deployments to validate trust performance under production loads. Use rust testing framework for unit integration and property based testing before rollouts Phase two deployments start with non-critical parts, then migrate to the code routing functions. This approach minimizes risk while steadily replacing fragile legacy code. Key takeaways. Rust lets us achieve safety without sacrificing the speed. Zero. Copy processing and fearless concurrency means fewer CPUs, low latency and higher throughput. Rust deterministic performance makes it AI ready, enabling in the in path. ML interference for the smarting. Thank you for the opportunity. Have a great day.