Rust in Production

As a kid, I was always fascinated by space tech. That fascination has only grown as I've learned more about the engineering challenges involved in space exploration. In this episode, we talk to Vegard Sandengen, a Rust engineer at KSAT, a company that provides ground station services for satellites. They use Rust to manage the data flow from hundreds of satellites, ensuring that data is received, processed, and stored efficiently. This data is then made available to customers around the world, enabling them to make informed decisions based on real-time satellite data. We dive deep into the technical challenges of building reliable, high-performance systems that operate 24/7 to capture and process satellite data. Vegard shares insights into why Rust was chosen for these mission-critical systems, how they handle the massive scale of data processing, and the unique reliability requirements when dealing with space-based infrastructure. From ground station automation to data pipeline optimization, this conversation explores how modern systems programming languages are enabling the next generation of space technology infrastructure. About KSAT KSAT, or Kongsberg Satellite Services, is a global leader in providing ground station services for satellites. The company slogan is "We Connect Space And Earth," and their mission-critical services are used by customers around the world to access satellite data for a wide range of applications, including weather monitoring, environmental research, and disaster response. About Vegard Sandengen Vegard Sandengen is a Rust engineer at KSAT, where he works on the company's data management systems. He has a Master's degree in computer science and has been working in the space industry for several years. At KSAT, Vegard focuses on building high-performance data processing pipelines that handle satellite telemetry and payload data from ground stations around the world. His work involves optimizing real-time data flows and ensuring system reliability for mission-critical space operations. Links From The Episode * SpaceX [https://www.spacex.com/] - Private space exploration company revolutionizing satellite launches * CCSDS [https://ccsds.org/] - Space data systems standardization body * Ground Station [https://en.wikipedia.org/wiki/Ground_station] * Polar Orbit [https://en.wikipedia.org/wiki/Polar_orbit] - Orbit with usually limited ground station visibility * TrollSat [https://en.wikipedia.org/wiki/Troll_Satellite_Station] - Remote Ground Station in Antarctica * OpenStack [https://www.openstack.org/] - Build-your-own-cloud software stack * RustConf 2024: K2 Space Lightning Talk [https://youtu.be/rME_t6Jn_Kw?list=PL2b0df3jKKiTWZeF7cip6ZUsaVXxWioRi&t=736] - K2 Space's sponsored lightning talk, talking about 100% Rust based satellites * K2 Space [https://www.k2space.com/] - Space company building satellites entirely in Rust * Blue Origin [https://www.blueorigin.com/] - Space exploration company focused on reusable rockets * Rocket Lab [https://www.rocketlabusa.com/] - Small satellite launch provider * AWS Ground Station [https://aws.amazon.com/ground-station/] - Cloud-based satellite ground station service * Strangler Pattern [https://en.wikipedia.org/wiki/Strangler_fig_pattern] - A software design pattern to replace legacy applications step-by-step * Rust by Example: New Type Idiom [https://doc.rust-lang.org/rust-by-example/generics/new_types.html] - Creating new wrapper types to leverage Rust's type system guarantees for correct code * serde [https://serde.rs/] - Serialization and deserialization framework for Rust * utoipa [https://github.com/juhaku/utoipa] - OpenAPI specification generation from Rust code * serde-json [https://github.com/serde-rs/json] - The go-to solution for parsing JSON in Rust * axum [https://github.com/tokio-rs/axum] - Ergonomic web framework built on tokio and tower * sqlx [https://github.com/launchbadge/sqlx] - Async SQL toolkit with compile-time checked queries * rayon [https://github.com/rayon-rs/rayon] - Data parallelism library for Rust * tokio [https://tokio.rs/] - Asynchronous runtime for Rust applications * tokio-console [https://github.com/tokio-rs/console] - Debugger for async Rust applications * tracing [https://tracing.rs/] - Application-level tracing framework for async-aware diagnostics * W3C Trace Context [https://www.w3.org/TR/trace-context/] - Standard for distributed tracing context propagation * OpenTelemetry [https://opentelemetry.io/] - Observability framework for distributed systems * Honeycomb [https://www.honeycomb.io/] - Observability platform for complex distributed systems * Azure Application Insights [https://learn.microsoft.com/en-us/azure/azure-monitor/app/app-insights-overview] - Application performance monitoring service Official Links * KSAT [https://www.ksat.no/] * Vegard on GitHub [https://github.com/veeg]

Handling secrets is extremely hard. You have to keep them safe (obviously), while at the same time you need to integrate with a ton of different systems and always provide a great user-experience, because otherwise people will just find a way around your system. When talking to peers, a lot of people mention 1Password as a company that nailed this balance. In today's episode, I talk to Andrew about how 1Password uses Rust to build critical systems that must never fail, how Rust helps them handle secrets for millions of users, and the lessons they learned when adopting Rust in their stack. About 1Password 1Password is a password manager that helps users securely store and manage their passwords, credit card information, and other sensitive data. It provides a user-friendly interface and strong security features to protect users' secrets across multiple devices. About Andrew Burkhart Andrew is a Senior Rust Developer at 1Password in the Product Foundations org, on the Frameworks team and specifically on the Core Platform squad handling the asynchronous frameworks other developers use to build features (i.e. requests into the Rust core from the Native clients, data sync, etc.). He specifically specialized in that synchronization process, getting data federated from cloud to clients to native apps and back. Links From The Episode * Backend for Frontend Pattern [https://samnewman.io/patterns/architectural/bff/] - Architectural pattern for creating dedicated backends for specific frontends * typeshare [https://github.com/1Password/typeshare] - Generate types for multiple languages from Rust code * zeroizing-alloc [https://github.com/1Password/zeroizing-alloc] - 1Password's minimal secure heap zero-on-free implementation for Rust * arboard [https://github.com/1Password/arboard] - Cross-platform clipboard manager written in Rust * passkey-rs [https://github.com/1password/passkey-rs] - Pure Rust implementation of the WebAuthn Passkey specification * WebAssembly (WASM) [https://webassembly.org/] - Binary instruction format for portable execution across platforms * tokio [https://tokio.rs/] - The de facto standard async runtime for Rust * Clippy [https://github.com/rust-lang/rust-clippy] - A collection of lints to catch common mistakes in Rust * cargo-deny [https://github.com/EmbarkStudios/cargo-deny] - Cargo plugin for linting dependencies, licenses, and security advisories * Nix [https://nixos.org/] - Purely functional package manager for reproducible builds * Nix Flakes [https://nixos.wiki/wiki/Flakes] - Experimental feature for hermetic, reproducible Nix builds * direnv [https://direnv.net/] - Load and unload environment variables based on current directory * ACM: Spotify Guilds [https://cacm.acm.org/research/spotify-guilds/] - A study into Spotify's Agile Model's Guilds * axum [https://github.com/tokio-rs/axum] - Ergonomic and modular web framework built on tokio and tower * tower [https://github.com/tower-rs/tower] - Library for building robust networking clients and servers * tracing [https://github.com/tokio-rs/tracing] - Application-level tracing framework for async-aware diagnostics * rusqlite [https://github.com/rusqlite/rusqlite] - Ergonomic wrapper for SQLite in Rust * mockall [https://docs.rs/mockall/latest/mockall/] - Powerful mock object library for Rust * pretty_assertions [https://docs.rs/pretty_assertions/latest/pretty_assertions/] - Better assertion macros with colored diff output * neon [https://neon-rs.dev/] - Library for writing native Node.js modules in Rust * nom-supreme [https://docs.rs/nom-supreme/latest/nom_supreme/] - Parser combinator additions and utilities for nom * crane [https://github.com/ipetkov/crane] - Nix library for building Cargo projects * Rust in Production: Zed [https://github.com/corrode/corrode.github.io/blob/80f4bef34c80f2f98b4e08592893466e9fd85e2b/podcast/s03e01-zed] - High-performance code editor built in Rust * tokio-console [https://github.com/tokio-rs/console] - Debugger for async Rust programs using tokio * Rust Atomics and Locks by Mara Bos [https://marabos.nl/atomics/] - Free online book about low-level concurrency in Rust * The Rust Programming Language (Brown University Edition) [https://rust-book.cs.brown.edu/] - Interactive version of the Rust Book with quizzes * Rustlings [https://github.com/rust-lang/rustlings] - Small exercises to get you used to reading and writing Rust code Official Links * 1Password [https://1password.com/] * Andrew on GitHub [https://github.com/DrewBurkhart] * Andrew on LinkedIn [https://www.linkedin.com/in/andrewburkhartdev/]

Recently I was in need of a simple job queue for a Rust project. I already had Postgres in place and wondered if I could reuse it for this purpose. I found Tembo [https://www.tembo.io/], a simple job queue written in Rust that uses Postgres as a backend. It fit the bill perfectly. In today's episode, I talk to Adam Hendel [https://www.linkedin.com/in/adam-hendel/], the founding engineer of Tembo, about their project, PGMQ, and how it came to be. We discuss the design decisions behind job queues, interfacing from Rust to Postgres, and the engineering decisions that went into building the extension. It was delightful to hear that you could build all of this yourself, but that you would probably just waste your time doing so and would come up with the same design decisions as Adam and the team. About Tembo Tembo builds developer tools that help teams build and ship software faster. Their first product, PGMQ [https://github.com/pgmq/pgmq/], was created to solve the problem of job queues in a simple and efficient way, leveraging the power of Postgres. They since made a pivot to focus on AI-driven code assistance, but PGMQ can be used independently and is available as an open-source project. About Adam Hendel Adam Hendel is the founding engineer at Tembo, where he has been instrumental in developing PGMQ and other tools like pg_vectorize [https://github.com/ChuckHend/pg_vectorize]. He has since moved on to work on his own startup, but remains involved with the PGMQ project. Links From The Episode * PostgreSQL [https://www.postgresql.org/about/] - Super flexible ~40 year old relational database that just works * R [https://www.r-project.org/] - Statistical Programming Language * pgrx [https://github.com/pgcentralfoundation/pgrx/] - Extend Postgres with Rust * Postgres Docs: PL/pgSQL [https://www.postgresql.org/docs/current/plpgsql.html] - Scripting with Procedural Language in PostgreSQL * Postgres Docs: SPI [https://www.postgresql.org/docs/current/spi.html] - The Postgres Server Programming Interface * pgmq [https://github.com/pgmq/pgmq] - A lightweight message queue extension, initially written in Rust * Tembo Blog: Introducing PGMQ [https://www.tembo.io/blog/introducing-pgmq] - a blog post about the project * sqlx [https://github.com/launchbadge/sqlx] - All of the great things of an ORM, without all of the bad things of an ORM * tokio [https://tokio.rs/] - The de facto standard async runtime for Rust * AWS SQS [https://aws.amazon.com/sqs/] - Amazon Web Services Simple Queue Service * Postgres Docs: LISTEN [https://www.postgresql.org/docs/current/sql-listen.html] - The native Postgres sub part of of pubsub * Postgres Docs: NOTIFY [https://www.postgresql.org/docs/current/sql-notify.html] - The native Postgres pub part of of pubsub * tokio-stream [https://docs.rs/tokio-stream/latest/tokio_stream/] - Tokio utility for asynchronous series of values * Postgres Docs: Full Text Search [https://www.postgresql.org/docs/current/textsearch.html] - Postgres included FTS capabilities * pgvector [https://github.com/pgvector/pgvector] - The standard extension for vector/AI workloads in Postgres * pg_vectorize [https://github.com/ChuckHend/pg_vectorize] - Automatically create embeddings for use with pgvector * Python Standard Library: None [https://docs.python.org/3/library/constants.html#None] - A type, but not an enum * Rust in Production: Astral with Charlie Marsh [https://corrode.dev/podcast/s04e03-astral/] - Massively improving Python day 1 experience * Hugging Face candle [https://github.com/huggingface/candle] - Use ML models in Rust Official Links * Tembo [https://www.tembo.io/] * Adam on LinkedIn [https://www.linkedin.com/in/adam-hendel/] * Adam on GitHub [https://github.com/ChuckHend]

Few developers have been as influential to my career as Niko Matsakis. Of course he is a world-class engineer with a PhD from ETH Zürich, a Rust core maintainer who has been working on the language for way more than a decade, and a Senior Principal Engineer at AWS. But more importantly, he is an empathetic human and an exceptional communicator. I've personally been waiting for one year to get him on the show and steal one hour of his precious time. Now, finally, I got my chance at live recording at Rust Week 2025. The result is everything I hoped for: a trip down memory lane which takes us back to the early days of Rust, an honest and personal look at Rust's strengths and weaknesses, and a glimpse into the future of the language. All of that packed with insightful anecdotes based on Niko's decades of experience. If you like Rust, you will enjoy this episode. About Rust Rust is the language which brought us all together. What started as a side-project of Graydon Hoare, a single developer at Mozilla, has grown into a worldwide community of hobbyists, professionals, and companies which all share the same goal: to build better, safer software paired with great ergonomics and performance. About Niko Matsakis Niko is a long-time Rust core team member, having joined the project in 2012. He was and still is part of the team which designed and implemented Rust's borrow checker, which is the language's most important feature. He has been a voice of reason and a guiding light for many of us, including myself. His insightful talks and blog posts have helped countless developers to see the language and its goals in a new light. Special Thanks Thanks to RustNL [https://rustnl.org/], the organizers of Rust Week 2025 for inviting Simon and me to record this episode live. They did a fantastic job organizing the event, and it was an honor to be part of it. Proudly Supported by CodeCrafters CodeCrafters helps you become proficient in Rust by building real-world, production-grade projects. Learn hands-on by creating your own shell, HTTP server, Redis, Kafka, Git, SQLite, or DNS service from scratch.  Start for free today and enjoy 40% off any paid plan by using this link [https://app.codecrafters.io/join?via=mre].  Links From The Episode * RustWeek 2025 [https://rustweek.org/] - Rust conference in Utrecht where we recorded this live episode * DataPower [https://en.wikipedia.org/wiki/DataPower] - Niko's employer before working on Rust * XSLT [https://en.wikipedia.org/wiki/XSLT] - Language to transform arbitrarily shaped XML into different arbitrary shapes * ETH Zürich [https://ethz.ch/] - Niko's Alma Mater * Mozilla [https://www.mozilla.org/en-GB/] - Niko's first employer while working on Rust * rustboot [https://github.com/rust-lang/rust/tree/ef75860a0a72f79f97216f8aaa5b388d98da6480/src/boot] - Rust's first compiler written in OCaml * Don Quixote [https://en.wikipedia.org/wiki/Don_Quixote] - Personification of impractical idealism, just like Rust was in the beginning * Steve Klabnik's FOSDEM talk [https://archive.fosdem.org/2015/schedule/event/the_story_of_rust/] - Coining "The Graydon years", Slides [https://steveklabnik.github.io/history-of-rust/], Recording of the same talk for ACM [https://youtu.be/79PSagCD_AY] * Rust 0.2 Keywords [https://github.com/rust-lang/rust/blob/0.2/doc/rust.md#keywords] - ret for return, cont for continue * Boxes in Rust 0.8 [https://github.com/rust-lang/rust/blob/0.8/doc/tutorial.md#boxes] - ~T and @T as syntax features instead of Box and Rc * Green Threads [https://en.wikipedia.org/wiki/Green_thread] - Like OS threads, but greener! * std::threads [https://doc.rust-lang.org/std/thread/index.html] - Not green, just part of the standard library * std::rc::Rc [https://doc.rust-lang.org/std/rc/struct.Rc.html] - The @T of std * std::boxed::Box [https://doc.rust-lang.org/std/boxed/struct.Box.html] - The ~T of std with some special compiler sauce * std::sync::Arc [https://doc.rust-lang.org/std/sync/struct.Arc.html] - Thread safe Rc * pyo3::Py [https://docs.rs/pyo3/latest/pyo3/struct.Py.html] - A pointer type in a different library! * The Rust Book: Understanding Ownership [https://doc.rust-lang.org/book/ch04-00-understanding-ownership.html] - Ownership and borrowing are the first third of "the simple core of Rust" * The Rust Book: Using Trait Objects [https://doc.rust-lang.org/book/ch18-02-trait-objects.html] - Trait-based dispatch being the second part of "the simple core of Rust" * std::marker::Send [https://doc.rust-lang.org/std/marker/trait.Send.html] - A trait without even a method to dispatch, aptly placed in the marker module * std::marker::Sync [https://doc.rust-lang.org/std/marker/trait.Sync.html] - Another example of a marker trait * Linear Type Systems [https://en.wikipedia.org/wiki/Substructural_type_system#Linear_type_systems] - Foundational research topic for borrowing in Rust * regex [https://github.com/rust-lang/regex] - "Real stuff" built in Rust * rayon [https://github.com/rayon-rs/rayon] - Turning iterators into parallel processing * Tokio Async Runtime [https://tokio.rs/] - An entire async ecosystem as a perfomant library * Comment on RFC 2394 [https://github.com/rust-lang/rfcs/pull/2394#discussion_r179909812] - The beginning of the await x / x.await discussion? * Alex Crichton [https://github.com/alexcrichton] - Rust compiler, wasm, and lang-advisors team member * cramertj [https://github.com/cramertj] - Rust lang-advisors and libs-contributors team member * withoutboats [https://without.boats/] - Rust team alumni * Carl Lerche [https://carllerche.com/] - tokio maintainer * aturon [https://aturon.github.io/] - Rust team alumni * ALGOL 60 [https://en.wikipedia.org/wiki/ALGOL_60#Code_sample_comparisons] - Doesn't look like C * try blocks [https://doc.rust-lang.org/nightly/unstable-book/language-features/try-blocks.html] - Do we need a postfix match operator for this? * Rust Blog: Announcing Rust 1.31 and Rust 2018 [https://blog.rust-lang.org/2018/12/06/Rust-1.31-and-rust-2018/] - A watershed moment for Rust * Non-lexical lifetimes [https://blog.rust-lang.org/2018/12/06/Rust-1.31-and-rust-2018/#non-lexical-lifetimes] - Included in 1.31 and Rust 2018 * Santiago Pastorino [https://santiagopastorino.com/] - Rust compiler contributor, worked on non-lexical lifetimes * Makefile Example [https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/Makefile] - "We don't need cargo, Make is fine" * Rust Blog: Laying the foundation for Rust's future [https://blog.rust-lang.org/2020/08/18/laying-the-foundation-for-rusts-future/] - Mozilla's parting gift to Rust? * Tyler Mandry [https://github.com/tmandry] - Rust lang team co-lead with Niko * Josh Triplett [https://joshtriplett.org/] - Rust lang, cargo, and libs team member * Amazon S3 Express One Zone storage class [https://aws.amazon.com/s3/storage-classes/express-one-zone/] - Super low latency S3, written in Rust * Amazon Aurora DSQL [https://aws.amazon.com/rds/aurora/dsql/] - Serverless SQL, an AWS project that started 100% in JVM and finished 100% Rust * Just make it scale: An Aurora DSQL story [https://www.allthingsdistributed.com/2025/05/just-make-it-scale-an-aurora-dsql-story.html] - Blog post detailing the Aurora DSQL Rust rewrite * Rust in 2025: Targeting foundational software [https://smallcultfollowing.com/babysteps/blog/2025/03/10/rust-2025-intro/] - Niko's vision for Rust * Be excellent to each other [https://youtu.be/rph_1DODXDU] - Party on dudes! Official Links * Rust Language [https://www.rust-lang.org/] * Rust Foundation [https://rustfoundation.org/] * Niko Matsakis' Homepage [https://smallcultfollowing.com/babysteps/] * Niko Matsakis on GitHub [https://github.com/nikomatsakis]

Up until a few years ago, Python tooling was a nightmare: basic tasks like installing packages or managing Python versions was a pain. The tools were brittle and did not work well together. Then, suddenly, we saw a renaissance of new ideas in the Python ecosystem. It started with Poetry [https://python-poetry.org/] and pipx [https://pypa.github.io/pipx/] and continued with tooling written in Rust like rye [https://rye.astral.sh/], which later got incorporated into Astral [https://astral.sh/]. Astral in particular contributed a very important piece to the puzzle: uv -- an extremely fast Python package and project manager that supersedes all previous attempts; For example, it is 10x-100x faster than pip. In this episode I talk to Charlie Marsh, the Founder and CEO of Astral. We talk about Astral's mission and how Rust plays an important role in it. About Astral Astral is a company that builds tools for Python developers. What sounds simple is actually a very complex problem: Python's ecosystem is huge, but fragmented and often incompatible. Astral’s mission is to make the Python ecosystem more productive by building high-performance developer tools, starting with Ruff. In their words: "Fast, unified, futuristic." About Charlie Marsh Charlie is a long-time open source developer and entrepreneur. He has an impressive CV, graduating with highest honors from Princeton University. After that, he worked at Khan Academy and others before eventually founding Astral in '22. Charlie is an engaging speaker and a great communicator. Proudly Supported by CodeCrafters CodeCrafters helps you become proficient in Rust by building real-world, production-grade projects. Learn hands-on by creating your own shell, HTTP server, Redis, Kafka, Git, SQLite, or DNS service from scratch.  Start for free today and enjoy 40% off any paid plan by using this link [https://app.codecrafters.io/join?via=mre].  Links From The Episode * ruff [https://docs.astral.sh/ruff/] - Python static linter and formatter written in Rust * uv [https://docs.astral.sh/uv/] - Python package and project manager written in Rust * rustfmt [https://github.com/rust-lang/rustfmt] - Rust code formatter * clippy [https://github.com/rust-lang/rust-clippy/] - Linter for Rust code * The Rust Programming Language: Cargo Workspaces [https://doc.rust-lang.org/book/ch14-03-cargo-workspaces.html] - The Rust Book's chapter on workspaces * pip [https://pip.pypa.io/en/stable/] - Package Installer for Python * pip documentation: Requirements File Format [https://pip.pypa.io/en/stable/reference/requirements-file-format/] - A description of the format of requirements.txt, including a list of embedded CLI options * uv's CI [https://github.com/astral-sh/uv/tree/main/.github/workflows] - Build scripts for many different platforms * jemalloc [https://jemalloc.net/] - Alternative memory allocator * zlib-ng [https://github.com/zlib-ng/zlib-ng] - Next Generation zlib implementation in C * reqwest [https://github.com/seanmonstar/reqwest] - An easy and powerful Rust HTTP Client * zlib-rs [https://github.com/trifectatechfoundation/zlib-rs] - Pure Rust implementation of zlib * XCode Instruments [https://developer.apple.com/tutorials/instruments] - Native macOS performance profiler * CodSpeed [https://codspeed.io/] - Continuous benchmarking in CI * hyperfine [https://github.com/sharkdp/hyperfine] - "macro benchmarking" tool, coincidentally written in Rust * samply [https://github.com/mstange/samply] - Sampling based profiler written in Rust * cargo flamegraph [https://github.com/flamegraph-rs/flamegraph] - Cargo profiling plugin * tokio [https://tokio.rs] - Asynchronous runtime for Rust * curl-rust [https://github.com/alexcrichton/curl-rust] - Network API used in cargo * tar-rs [https://github.com/alexcrichton/tar-rs] - Sync tar crate * async-tar [https://github.com/dignifiedquire/async-tar] - Async tar crate based on the async_std runtime * tokio-tar [https://github.com/vorot93/tokio-tar] - Async tar crate based on tokio * astral-tokio-tar [https://github.com/astral-sh/tokio-tar] - Async tar crate based on tokio, maintained by Astral * RustPython [https://rustpython.github.io/] - Python interpreter written in Rust * lalrpop [https://github.com/lalrpop/lalrpop] - The parser generator used by RustPython * Charlie's EuroRust 2024 Talk [https://youtu.be/zOY9mc-zRxk] - Mentions the version number parser at 18:45 * ripgrep [https://github.com/BurntSushi/ripgrep] - Andrew Gallant's idiomatic Rust project, which also happens to be a very fast CLI file search tool Official Links * Astral [https://astral.sh/] * Charlie's Website [https://crmarsh.com/] * Charlie on GitHub [https://github.com/charliermarsh]