Veo with Anders Hellerup Madsen and Gorm Casper

ClickHouse with Alexey Milovidov and Austin Bonander

There's a particular kind of pressure that comes with maintaining software at the very bottom of someone else's stack. ClickHouse lives in exactly that spot: roughly 1.5 million lines of mostly C++ and tens of millions of tests every single day. So what happens when you start introducing Rust into a codebase like that? Not as a rewrite, but linked into a C++ server with a CMake build process that has to be reproducible and FIPS compliant? In today's episode, we get into the messy, interesting reality. We talk about the question of whether the hardest part is Rust the language or Rust the ecosystem. My guests come at this from two very different angles. Alexey Milovidov is the creator of ClickHouse and its CTO. He started the project back in 2009 and has spent decades thinking about performance, correctness, and what it actually takes to build a production database. Austin Bonander is a Senior Software Engineer at ClickHouse and a renowned open-source maintainer of sqlx [https://github.com/launchbadge/sqlx]. He works close to the Rust tooling and the CLI. Together we talk about where Rust fits inside a C++ monolith, what it would take for Rust to earn a rewrite of core components, supply-chain and compliance headaches, and whether Rust is heading for the same accumulation of regrets that every "trendy" language eventually accumulates. About ClickHouse ClickHouse [https://clickhouse.com/] is an open-source, column-oriented OLAP database management system built for real-time analytics over very large datasets. The first version was written in 2009, it went into production in 2012, and it was open-sourced in 2016. Today it's roughly 1.5 million lines of mostly C++, exercised by tens of millions of automated tests per day and a heavy regime of sanitizers and linters. ClickHouse is known for its raw query performance, and it powers analytics workloads at companies all over the world, from observability and logging platforms to large-scale data warehouses. About Alexey Milovidov Alexey Milovidov is the creator of ClickHouse and the CTO of ClickHouse Inc. He started the project in 2009 while working at Yandex and has guided its evolution from an internal analytics tool into one of the most popular open-source databases in the world. He's spent his career obsessing over performance, correctness, and the kind of low-level engineering discipline it takes to keep a database trustworthy at scale. About Austin Bonander Austin Bonander is a Senior Software Engineer at ClickHouse, where he works on Rust tooling and the ClickHouse CLI. He is a long-time member of the Rust community and a maintainer of sqlx [https://github.com/launchbadge/sqlx], the async, pure-Rust SQL toolkit. Through that work he has thought deeply about database protocols, API ergonomics, and the long-term maintenance burden of widely used open-source libraries. Links From The Episode * OLAP [https://en.wikipedia.org/wiki/Online_analytical_processing] - A type of database used for analytics, not storing relational data * sqlx [https://github.com/launchbadge/sqlx] - The async, pure-Rust SQL toolkit Austin maintains * Official /r/rust "Who's Hiring" thread for job-seekers and job-offerers [https://www.reddit.com/r/rust/search?sort=new&restrict_sr=on&q=flair%3A%F0%9F%92%BC%2Bjobs%2Bmegathread] - Where Austin found the Clickhouse job * Clickhouse's C++ & Rust Journey [https://www.youtube.com/watch?v=cIXKsb0FYpc] - Alexeys talk at P99 CONF 2025 * No-Panic Rust: A Nice Technique for Systems Programming [https://blog.reverberate.org/2025/02/03/no-panic-rust.html] - Using linker checks to guarantee no panic calls in Rust code * delta-kernel-rs [https://github.com/delta-io/delta-kernel-rs] - A Rust implementation of the Delta Lake kernel, with a non-trivial dependency graph * ring [https://github.com/briansmith/ring] - BoringSSL crypto code packaged as a Rust crate * H3 [https://h3geo.org/] - Uber’s Geo Hashing using hexagons, currently used in ClickHouse * H3O [https://docs.rs/h3o/latest/h3o/] - The same H3 Geo Hashing algorithm implemented in Rust, with better performance * stdx [https://github.com/brson/stdx] - An attempt at creating an extended standard library with commonly used crates * Hyrum's Law [https://www.hyrumslaw.com/] - With enough users, every observable behavior of your system will be depended on by somebody * Corrosion [https://github.com/corrosion-rs/corrosion] - CMake integration for Rust, used to link Rust into a C++ build * Cargo [https://doc.rust-lang.org/cargo/] - Rust's build system and package manager, not designed for multi-language monorepos * CMake [https://cmake.org/] - The build system that dominates the ClickHouse server * Poco [https://pocoproject.org/] - The C++ libraries used by the ClickHouse server, without HTTP/2 support * hyper [https://hyper.rs/] - A fast HTTP implementation for Rust Official Links * ClickHouse Website [https://clickhouse.com/] * ClickHouse on GitHub [https://github.com/ClickHouse/ClickHouse] * clickhouse-rs [https://github.com/ClickHouse/clickhouse-rs] - The Rust client for ClickHouse, supporting both its native TCP and HTTP interfaces * Alexey Milovidov on GitHub [https://github.com/alexey-milovidov] * Austin Bonander on GitHub [https://github.com/abonander]

Veo with Anders Hellerup Madsen and Gorm Casper

I don't know about you, but to me there are few things as interesting as the hardware/software interface: the point where carefully written code meets the messy, physical world of sensors, lenses, and real-time constraints. It's where a clever abstraction either holds up or falls apart the moment a real signal hits it. That makes Veo a perfect guest. The Copenhagen-based company builds AI-powered cameras that record and analyze sports matches, from grassroots football pitches to professional clubs, and then turn hours of raw footage into something coaches and players can actually use: automatic highlights, player tracking, and match analysis. To get there, they have to capture panoramic video on a custom camera, follow the action without an operator, and crunch an enormous amount of data, reliably and at scale. My guests sit on both sides of that interface. Anders Hellerup Madsen works close to the metal on the camera itself, on the embedded firmware and the GStreamer [https://gstreamer.freedesktop.org/] media pipeline that turns raw sensor data into video. Gorm Casper works further up the stack, on the backend that ingests, processes, and analyzes those matches in Rust. Together we talk about where Rust fits across that whole journey, the trade-offs of doing media and computer vision work in a systems language, and what convinced a sports-tech company to bet on Rust for the parts that absolutely cannot fall over. About Veo Veo [https://www.veo.co/] (Veo Technologies) is a Danish sports-tech company, headquartered in Copenhagen, that builds AI-powered cameras and a video platform for recording and analyzing matches. Instead of relying on a human camera operator, a Veo camera captures the entire pitch in panoramic video and uses computer vision to automatically follow the ball, generate highlights, and produce analysis that coaches, players, and clubs can use. What started in football has grown into a platform used by tens of thousands of teams across the world, spanning many sports, from amateur clubs to professional organizations. About Anders Hellerup Madsen Anders Hellerup Madsen is a Senior Software Engineer at Veo, where he works on embedded firmware and on the GStreamer [https://gstreamer.freedesktop.org/]-based media processing pipeline that runs on the Veo camera. He is also a GStreamer contributor. About Gorm Casper Gorm Casper is a Software Engineer at Veo. After many years working on the frontend, he now spends his time on the backend, writing Rust. He holds a Master's in Digital Design & Communication from the IT University of Copenhagen. Links From The Episode * GStreamer [https://gstreamer.freedesktop.org/] - The open-source multimedia framework at the heart of Veo's camera pipeline * gstreamer-rs [https://gitlab.freedesktop.org/gstreamer/gstreamer-rs] - The Rust bindings for GStreamer * OpenCV [https://opencv.org/] - The open-source computer vision library * Nvidia Jetson [https://developer.nvidia.com/embedded-computing] - Like a Raspberry Pi, but with more video processing capabilities * glib [https://docs.gtk.org/glib/] - The foundation of gstreamer, also of GTK, Gnome, and many more * ffmpeg [https://ffmpeg.org/] - An easier video manipulation tool, but without good support for custom pipeline elements * CUDA [https://developer.nvidia.com/cuda-toolkit] - Nvidia's tooling to run C++ code on the GPU * Sebastian Dröge [https://coaxion.net/] - Amazing Rust and GStreamer developer * OCaml [https://ocaml.org/] - A really nice language and an inspiration for Rust * Rustonomicon [https://doc.rust-lang.org/nomicon/] - The dark arts of unsafe Rust * Latest Announcement from Nvidia - CUDA for Rust [https://www.marktechpost.com/2026/05/09/nvidia-ai-just-released-cuda-oxide-an-experimental-rust-to-cuda-compiler-backend-that-compiles-simt-gpu-kernels-directly-to-ptx/] - Nvidia's experimental Rust-to-CUDA compiler, cuda-oxide * Rust GPU [https://rust-gpu.github.io/] - Write and run GPU code in Rust, announced on 2026-05-12 * Temporal [https://temporal.io/] - A durable workflow engine * Rust in Production: Astral [https://github.com/corrode/corrode.github.io/blob/veo/podcast/s04e03-astral] - The Python company that does uv and ruff, with Rust * serde_json::Value [https://docs.rs/serde_json/latest/serde_json/enum.Value.html] - The Rust analogue to Python's dict * ReasonML [https://reasonml.github.io/] - OCaml with a better syntax * bedquilt [https://bedquilt.io/] - Write 80s Text Adventures with Rust * Rust Book: Transfer Data Between Threads with Message Passing [https://doc.rust-lang.org/book/ch16-02-message-passing.html] - The chapter explaining the Go motto "Do not communicate by sharing memory; instead, share memory by communicating" Official Links * Veo Website [https://www.veo.co/] * Anders Hellerup Madsen on LinkedIn [https://dk.linkedin.com/in/anders-hellerup-madsen-78751b3] * Anders Hellerup Madsen on GitLab (freedesktop) [https://gitlab.freedesktop.org/ahem] * Gorm Casper's Website [https://gormcasper.dk/] * Gorm Casper on LinkedIn [https://www.linkedin.com/in/gormc] * Gorm Casper on GitHub [https://github.com/casperin]

Rust for Linux with Alice Ryhl and Greg Kroah-Hartman

Hot off the press: this episode is a live recording from Rust Week [https://2026.rustweek.org/] in Utrecht, just two days ago. On stage with me are two people who hardly need an introduction in the Linux world: Greg Kroah-Hartman [http://www.kroah.com/linux/], Linux Foundation Fellow, stable kernel maintainer and an ambassador for the kernel, and Alice Ryhl [https://www.ryhl.io/], core maintainer of Tokio [https://tokio.rs/] and one of the driving forces behind Rust for Linux at Google. I have to admit a bit of personal history here: I first wrote about Greg more than 20 years ago for the German online newspaper Pro-Linux [https://www.pro-linux.de/]. Getting to sit down with him, and with Alice, in front of a live audience to talk about how Rust is reshaping the most important piece of infrastructure on the planet, was a genuine career highlight. We get into the big questions: Why does Alice believe that interop, not rewrites, is how Rust wins inside Linux? How do you carefully weave in Rust while maintaining a 35-million-line C codebase? And what does it actually feel like, day to day, to write kernel code in Rust? > “Rust is gonna save the Linux kernel.” — Greg Kroah-Hartman About Rust for Linux Rust for Linux [https://rust-for-linux.com/] is the project bringing the Rust programming language into the Linux kernel. After years of patches, proposals, and heated mailing list threads, Rust is now an officially supported [https://www.phoronix.com/news/Rust-To-Stay-Linux-Kernel] language inside the kernel tree, no longer an experiment. The work spans everything from the build system and the kernel crate to drivers, abstractions over core subsystems and brand-new pieces of infrastructure written entirely in Rust. About Greg Kroah-Hartman Greg Kroah-Hartman is a Linux Foundation Fellow, the maintainer of the stable Linux kernel branch, and the maintainer of, among many other things, the USB subsystem [https://docs.kernel.org/process/maintainers.html#usb-subsystem], the driver core, sysfs, debugfs, kobject, TTY layer and staging tree. He has been a central figure in Linux for over two decades, has written several books about kernel development, and is convinced Rust belongs in the kernel. About Alice Ryhl Alice Ryhl is a software engineer at Google working on Android and Rust for Linux, and a core maintainer of Tokio [https://tokio.rs/], the asynchronous runtime that over 50% of all crates on crates.io directly depends on. Inside the kernel she works on Binder, on async abstractions, and on the bindings that allow Rust drivers to talk safely to the rest of the kernel. About Rust Week Rust Week is an annual conference organized by RustNL. The 2026 edition took place in Utrecht, the Netherlands, from May 18 to May 23. It features talks, workshops, the Rust All Hands, and expert sessions on a wide variety of topics revolving around Rust. This episode was recorded live on stage during the conference. Thanks to the Rust Week team who made this recording possible! [https://2026.rustweek.org/about/] Learn more about Rust Week on their website [https://rustweek.org/]. Links From The Episode * Linux Docs: USB Subsystem Maintainer [https://docs.kernel.org/process/maintainers.html?highlight=Greg%20Kroah-Hartman#usb-subsystem] - Greg’s first contribution led to him maintaining the USB subsystem, and much more * The Register: Happy birthday, Linux: From a bedroom project to billions of devices in 30 years [https://www.theregister.com/software/2021/08/25/happy-birthday-linux-from-a-bedroom-project-to-billions-of-devices-in-30-years/1295876] - An interview with Greg celebrating the 30 year anniversary of the Linux kernel * Tokio [https://tokio.rs/] - Another big project maintained by Alice * RustWeek: Untrusted data in Linux — How Rust is going to save us [https://2026.rustweek.org/talks/greg] - Greg’s talk at RustWeek; Rust is gonna save Linux?! * Rust in Production: Rust for Linux [https://corrode.dev/podcast/s05e06-rust4linux/] - With Danilo, one of the co-maintainers with Greg on the Driver Core subsystem and others * Phoronix: New Linux Patch Confirms: Rust Experiment Is Done, Rust Is Here To Stay [https://www.phoronix.com/news/Rust-To-Stay-Linux-Kernel] - The official end of experimental Rust * Linux Plumbers Conference [https://lpc.events/] - A big conference for all levels of kernel developers * std::boxed [https://doc.rust-lang.org/std/boxed/index.html] - The most basic kind of pointer in Rust * kernel::list::List [https://rust.docs.kernel.org/kernel/list/struct.List.html] - Linux’ linked list Rust binding * core lib [https://doc.rust-lang.org/core/] - The most fundamental parts of the Rust libraries * alloc lib [https://doc.rust-lang.org/alloc/] - All things in the standard library that only require an allocator, not used by the kernel anymore * std lib [https://doc.rust-lang.org/std/index.html] - The thing most people think of as the standard library, containing things like file access which requires running on a kernel * QR code generator for kernel crashes [https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/gpu/drm/drm_panic_qr.rs] - First Rust code added to the kernel * Linux Rust Architecture support [https://origin.kernel.org/doc/html/latest/rust/arch-support.html] - Missing some big platforms like S390 (IBM Mainframes) and MIPS (a lot of consumer networking hardware) * sched_ext Schedulers written in Rust [https://sched-ext.com/docs/scheds/rust] - sched_lavd shows promise for video game performance, and servers? * Aya [https://aya-rs.dev/] - Build eBPF programs with nothing more than Rust and the Linux kernel * RustWeek: Completion-based IO [https://2026.rustweek.org/talks/alice] - Alice’s talk at RustWeek about IO * WE DO NOT BREAK USERSPACE [https://linuxreviews.org/WE_DO_NOT_BREAK_USERSPACE] - An e-mail from Linus explaining the mantra in typical Linus fashion * Linux clippy config [https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/.clippy.toml] - It’s not pedantic! * Rust code style [https://origin.kernel.org/doc/html/latest/rust/coding-guidelines.html] - Coding guidelines of the Linux project for Rust code * rustfmt config [https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/.rustfmt.toml] - Almost vanilla with some ideas for the future * clang-format config [https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/.clang-format#n805] - Added in 2018 and tabs won! * Coccinelle [https://www.kernel.org/doc/html/latest/dev-tools/coccinelle.html] - Semantic code transformation and the reason Greg lives in Europe * klint [https://github.com/Rust-for-Linux/klint] - Custom kernel specific lints, basically a repository of clippy lints for kernel code Official Links * Rust for Linux [https://rust-for-linux.com/] * Greg Kroah-Hartman on Wikipedia [https://en.wikipedia.org/wiki/Greg_Kroah-Hartman] * Greg Kroah-Hartman’s homepage (momentarily offline) [https://web.archive.org/web/20260226054256/http://www.kroah.com/linux/] * Greg Kroah-Hartman on Mastodon [https://social.kernel.org/gregkh] * Alice Ryhl’s website [https://www.ryhl.io/] * Alice Ryhl on GitHub [https://github.com/Darksonn]

NLnet Labs with Arya Khanna and Martin Hoffmann

Every time you load a website, send an email, or update an app, you're quietly relying on a handful of unglamorous services that route your packets to the right place: DNS to translate names into addresses, and BGP to figure out how to actually get there. When these systems break, or get attacked, the Internet doesn't just slow down but stops working. For more than 25 years, NLnet Labs has been one of the small, non-profit teams keeping that core infrastructure running. Their software, including the DNS servers NSD and Unbound, the RPKI tools Krill and Routinator, and the new DNSSEC signer Cascade, is deployed everywhere from hobbyist Pi-Hole setups to Let's Encrypt and major Internet operators. And increasingly, it's written in Rust! In this episode, I talk to Arya Khanna and Martin Hoffmann from NLnet Labs about what it takes to maintain critical Internet infrastructure as a small team, why they bet on Rust for new projects like the domain crate and Cascade and what the rest of us can learn from a codebase whose users include the people who keep your routes flowing. About NLnet Labs NLnet Labs is a non-profit foundation based in Amsterdam that develops open source software and open standards for the core infrastructure of the Internet. Since 1999, the small but dedicated team has built some of the most widely deployed building blocks of the modern web, including the authoritative DNS nameserver NSD [https://nlnetlabs.nl/projects/nsd/about/], the recursive DNS resolver Unbound [https://nlnetlabs.nl/projects/unbound/about/], and the RPKI tools Krill [https://github.com/NLnetLabs/krill] and Routinator [https://nlnetlabs.nl/projects/routing/routinator/], which secure global Internet routing. Their work is trusted by operators ranging from hobbyist Pi-Hole users to Let's Encrypt and major Internet service providers. In recent years, NLnet Labs has been steadily moving its new development to Rust, with projects like the domain [https://nlnetlabs.nl/projects/domain/about/] crate and the Cascade [https://nlnetlabs.nl/news/2025/Oct/07/cascade-0.1.0-released/] DNSSEC signer leading the way. Links From The Episode * NSD [https://nlnetlabs.nl/projects/nsd/about/] - NLNet Labs' first project * lychee [https://github.com/lycheeverse/lychee] - A link-checker that receives funding from NLNet (not NLNet labs!) * unbound [https://nlnetlabs.nl/projects/unbound/about/] - A DNS server like BIND, but only for recursive queries * Cascade [https://nlnetlabs.nl/news/2025/Oct/07/cascade-0.1.0-released/] - The new DNSSEC signing solution from NLNet Labs * Pi-Hole [https://pi-hole.net/] - A small usecase for unbound * Let's Encrypt [https://letsencrypt.org/] - A big user of unbound with scale and security requirements * Asahi Linux [https://asahilinux.org/] - Linux on Apple Silicon, mostly with Rust * Binder CVE [https://social.kernel.org/notice/B1JLrtkxEBazCPQHDM] - A CVE in Rust * LDNS [https://nlnetlabs.nl/projects/ldns/about/] - A collection of DNS functions, written in C, now in maintenance mode * domain [https://nlnetlabs.nl/projects/domain/about/] - The new collection of DNS functions, written in Rust * tokio [https://tokio.rs/] - The biggest shared dependency across the Rust ecosystem, first announced in 2017 * Rust in Production: Helsing with Jon Gjengset [https://corrode.dev/podcast/s06e02-helsing/] - You can take generics too far * bytes [https://github.com/tokio-rs/bytes] - Tokio's Arc of bytes * Arc Welding [https://en.wikipedia.org/wiki/Arc_welding] - The other type of "fixing" * Alejandra González' crate dependency analysis [https://tech.lgbt/@blyxyas/116252699616176134] - 46% of published crates depend directly on tokio * RPKI [https://en.wikipedia.org/wiki/Resource_Public_Key_Infrastructure] - Signing and validating IPs and routing information * Routinator [https://nlnetlabs.nl/projects/routing/routinator/] - A RPKI validator, one of the first Rust applications in production * hyper [https://hyper.rs/] - The ubiquitous HTTP crate * Krill [https://github.com/NLnetLabs/krill] - The RPKI Certificate Authority tool with "fun" shutdown code * Roto [https://codeberg.org/NLnetLabs/roto] - Tert's scripting language, used by another NLNet Labs project, Rotonda Official Links * NLnet Labs Website [https://nlnetlabs.nl] * Arya Khanna's Website [https://bal-e.org/] * Arya Khanna on GitHub [https://github.com/bal-e] * Arya Khanna on Mastodon [https://tech.lgbt/@bal4e] * Martin Hoffmann on GitHub [https://github.com/partim] * Martin Hoffmann on Mastodon [https://social.tchncs.de/@partim]

Helsing with Jon Gjengset

Jon Gjengset is one of the most recognizable names in the Rust community, the author of Rust for Rustaceans, a prolific live-streamer, and a long-time contributor to the Rust ecosystem. Today he works as a Principal Engineer at Helsing, a European defense company that has made Rust a foundational part of its engineering stack. Helsing builds safety-critical software for real-world defense applications, where correctness, performance, and reliability are non-negotiable. In this episode, Jon talks about what it means to build mission-critical systems in Rust, why Helsing bet on Rust from the start, and what lessons from his years of Rust education have shaped the way he writes and thinks about production code. About Helsing Founded in 2021, Helsing is a European defence company building AI-enabled software for some of the most demanding environments imaginable. Helsing's software runs where correctness is non-negotiable. That philosophy led them to Rust early on and they've leaned into it fully. From coordinate transforms to CRDT document stores to Protobuf package management, almost everything they build ends up being written in Rust. About Jon Gjengset Jon holds a PhD from MIT's PDOS group, where he built Noria, a high-performance streaming dataflow database, and later co-founded ReadySet to continue that work commercially. He then spent time building infrastructure at AWS, before joining Helsing as a Principal Engineer. Outside of his day job, he's been teaching Rust to the world through his livestreams and writing for years, which makes him a rare combination: someone who thinks deeply about both how to use Rust and how to explain it. Links From The Episode * Helsing AI selected for Eurofighter upgrade [https://helsing.ai/newsroom/helsing-ai-selected-for-eurofighter-upgrade] - Helsing's Eurofighter Project * CA-1 Europa [https://helsing.ai/europa] - Helsing's Autonomous Uncrewed Combat Aerial Vehicle * Rust in Python cryptography [https://cryptography.io/en/latest/faq/#why-does-cryptography-require-rust] - Rust being used in a Python library * Clippy Documentation: Adding Lints [https://doc.rust-lang.org/stable/clippy/development/adding_lints.html] - How to add custom lints to (your own fork of) clippy * anyhow's .context() [https://docs.rs/anyhow/latest/anyhow/trait.Context.html] - Use it everywhere, it's very very helpful * eyre [https://docs.rs/eyre/latest/eyre/] - A fork of anyhow with support for customizable, pluggable error report handlers * miette [https://docs.rs/miette/latest/miette/] - Fancy, diagnostic-rich error reporting for Rust with source snippets and labels * buffrs [https://github.com/helsing-ai/buffrs] - Helsing's Cargo-inspired package manager for Protocol Buffers, written in Rust * sguaba [https://github.com/helsing-ai/sguaba] - Helsing's Rust crate for type-safe coordinate system math, preventing unit and frame mix-ups at compile time * Sguaba: Type-safe spatial math in Rust [https://www.youtube.com/watch?v=kESBAiTYMoQ] - Jon's talk at Rust Amsterdam introducing sguaba and the type-system techniques behind it * Apache Avro [https://avro.apache.org/] - A compact binary serialization format for streaming data, with a Rust implementation available via the apache-avro crate * pubgrub [https://docs.rs/pubgrub/latest/pubgrub/] - A Rust implementation of the PubGrub version-solving algorithm, as used in Cargo and uv * CRDTs [https://en.wikipedia.org/wiki/Conflict-free_replicated_data_type] - Conflict-free Replicated Data Types: data structures that can be merged across distributed nodes without conflicts * ADR (Architecture Decision Record) [https://adr.github.io/] - A lightweight way to document important architectural decisions and their context * DSON: JSON CRDT using delta-mutations for document stores [https://dl.acm.org/doi/10.14778/3510397.3510403] - The 2022 paper that was the basis for Helsing's CRDT implementation * dson [https://docs.rs/dson/latest/dson/] - Helsing's Rust implementation of DSON * Jon's Livestreams on YouTube [https://www.youtube.com/@jonhoo] - Deep-dive Rust coding sessions where Jon implements real-world libraries and systems from scratch * WebAssembly with Rust [https://rustwasm.github.io/docs/book/] - The official Rust and WebAssembly book, covering a cool technology and useful skills to have as a Rust developer * Rust for Rustaceans [https://nostarch.com/rust-rustaceans] - Jon's book for intermediate Rust developers covering ownership, traits, async, and the finer points of the language * CVE-2024-24576: Cargo/tar supply chain vulnerability [https://blog.rust-lang.org/2023/08/03/cve-2022-46176.html] - A security issue in the tar crate that affected Cargo's package extraction * Wikipedia: Defence in Depth [https://en.wikipedia.org/wiki/Defence_in_depth_(non-military)#Information_security] - The security principle of using multiple independent layers of protection; Even with Rust you need multiple layers, there is no silver bullet * SBOMs (Software Bill of Materials) [https://www.cisa.gov/sbom] - A machine-readable inventory of all components in a software artifact; Cargo's lock files make this tractable for Rust projects * Helsing: AI-assisted vetting of software packages [https://blog.helsing.ai/posts/ai-assisted-vetting-of-software-packages/] - Make it more efficient to review dependencies you take in * Bevy [https://bevy.org/] - A game engine built entirely in Rust, and a notable example of a large, complex Rust dependency * Tauri [https://tauri.app/] - A Rust-powered framework for building lightweight desktop and mobile apps from a web frontend, an alternative to Electron Official Links * Helsing Website [https://helsing.ai] * Helsing Tech Blog [https://blog.helsing.ai] * Helsing on GitHub [https://github.com/helsing-ai] * Helsing on LinkedIn [https://www.linkedin.com/company/helsing/] * Jon Gjengset's Website [https://thesquareplanet.com] * Jon Gjengset on GitHub [https://github.com/jonhoo] * Jon Gjengset on YouTube [https://www.youtube.com/@jonhoo] * Jon Gjengset on Bluesky [https://bsky.app/profile/jonhoo.eu] * Rust for Rustaceans [https://nostarch.com/rust-rustaceans]