»Schedule // Talk
Wednesday, October 9
13:45-14:15
Main Stage
Production Unsafe Rust: Patterns for Zero-Copy Performance
When Safe Rust Meets Reality
Picture this: your beautifully crafted, idiomatic Rust service is processing 50MB/s when the business needs 5GB/s. Your network parser allocates on every packet when microseconds matter. Your SIMD experiments somehow made things slower. Welcome to the performance wall that separates hobby projects from production systems.
This is where unsafe Rust transforms from “dangerous territory to avoid” into “the tool that saves your career.
What Makes This Talk Different
Most unsafe Rust content focuses on how to write unsafe code. This talk focuses on when, why, and what happens after you ship it. These are battle-tested patterns from systems handling terabytes daily, not academic examples.
Who Should Attend
Perfect for you if:
• You’ve hit performance walls that safe Rust can’t break through
• You’re curious about unsafe but don’t know where to start safely
• You maintain high-performance Rust systems and need to justify architectural decisions
• You’re evaluating whether Rust can replace C/C++ in performance-critical applications
You’ll leave knowing:
• Exactly when unsafe provides real benefits vs. perceived ones, with decision frameworks you can apply immediately
• How to implement unsafe patterns that survive production code review and team turnover
• A systematic approach to weighing safety vs. performance trade-offs based on actual business impact
• Specific architectural patterns you can adapt to your performance bottlenecks
Why This Matters Now
As Rust moves into domains traditionally dominated by C and C++, the ability to use unsafe responsibly becomes a competitive advantage. The companies winning in performance-critical markets aren’t avoiding unsafe—they’re using it strategically and safely, with the engineering discipline to maintain it long-term.
Speaker
Muskan Paliwal
I’m a founding engineer with 3+ years of intensive Rust experience in production environments, specializing in performance-critical systems and enterprise-grade solutions.
As the founding engineer at Vibinex, I led the technical development of Git analysis tools where Rust became essential for the performance requirements we needed to meet. Working in a lean 3-person startup, I gained deep hands-on experience with Rust’s performance characteristics while building data processing systems that handle complex Git repository analysis at scale.
My Rust journey began out of necessity – when Python couldn’t deliver the performance our enterprise clients demanded, I dove deep into Rust to build our core Data Processing Unit. This experience taught me not just how to write Rust, but when and why unsafe optimizations become critical in real-world systems.
At Vibinex, I designed and implemented privacy-first architectures that required zero-copy processing and custom memory layouts to meet both performance and security requirements. These solutions directly contributed to closing enterprise deals where performance wasn’t just nice-to-have, but a fundamental requirement.
My background spans full-stack development, having migrated our entire platform from Python to Next.js while architecting PostgreSQL systems for complex query performance. This broad perspective helps me understand when Rust’s performance benefits justify the complexity, and when they don’t.
Coming from a conservative family in Rajasthan as the first daughter to pursue computer science, I’ve learned to prove my worth through practical results. My approach to unsafe Rust reflects this same pragmatism – it’s not about pushing boundaries for the sake of it, but about solving real problems that safe abstractions can’t handle.
I’m passionate about sharing practical knowledge that helps other developers make informed decisions about when to cross the safety boundary, and how to do it responsibly in production systems.