Rerun Blog

This looks very promising. I'll have to think my visualization cases against new possibilities this enables. I have been intermittently following Rerun, a "robotics-style data visualization" app [1]. Their architecture bears certain similarities [2]. Wgpu in both, egui and imgui, Rust with Python. Rerun's stack does compile to WASM and works in browser. Use cases seem different, but somewhat the same. I don't do scientific nor robotic stuff at all, so no opinions on feasibility of either... [1] https://rerun.io [2] https://github.com/rerun-io/rerun/blob/main/ARCHITECTURE.md

> In which world is Rust fantastic for writing desktop applications? Where are the mature Rust UI frameworks? Rust has come a remarkably long way [1] ! It's better than any language that isn't C/C++. We have bindings to all of the major UI toolkits, plus a lot of native toolkits. You can also use Electron/Tauri for Javascript, or Dioxus for something more performant. Egui is also really nice for dev tools. > What does this even mean? Rewrite It In Rust metrics tend to tell good stories. Developer blogs (links escaping me right now) show positive performance gains for lots of consumer desktop software written in whole or in parts using Rust. Discord, Slack, lots of other apps are starting to replace under-performing components in Rust. > For example? And what do you mean by "AI powered desktop apps"? Stuff like Zed [2] and the open source Photoshop-killer I'm working on (user-guided volumetric rendering, real time instructive Figma). The creator or egui works on Rerun [3], which is industrial / spatial visualization. Etc, etc. [1] https://areweguiyet.com/ [2] https://zed.dev/ [3] https://rerun.io/

Rerun | Remote | Stockholm, Sweden | Full-time https://rerun.io/ Rerun is the data layer for Physical AI; robotics, autonomous systems, AR/VR, and other embodied ML. We give engineers a single unified layer for multi-rate, multimodal data: the open-source Rerun SDK (Rust, built with egui) for logging, querying, visualizing, and training, plus Rerun Hub for large-scale storage and streaming from object storage. Most of our core, performance-critical code is Rust. This month we’re hiring for: - Rust Backend Engineers - Software Engineer, Infrastructure - Dataframe SDK Engineers - Robotics ML Engineers Check all roles and apply here: https://rerun.io/careers

Yes, rerun does replay, that was my main use case when prototyping. They've since raised more funding recently, and have larger use cases in mind for robotics: https://rerun.io/blog/physical-ai-data I've spoken with members of the team, and they're all great. Wouldn't hesitate to use the product / work with them anywhere.

Looks beautiful so congratulation for the launch. Not sure if today this is enough though without any kind of AI chat assistant. Trae [0] is based on VSCode and Jetbrains Fleet are good looking as well. Visualization is definitely a big plus but there is also alternative like using rerun [1] and dearpygui [2] or some VSCode plugins (Python Image Preview, AREPL for Python)- might be hard to compete with those free alternatives on a subscription model IMHO but good luck! [0] https://trae.ai/ [1] https://www.rerun.io/ [2] https://github.com/hoffstadt/DearPyGui

https://rerun.io the one that sponsors them and the author's app is one example

https://rerun.io/ Quite obvious, if you scroll to the "Getting Started" section.

Not exactly what you're asking for, but Rerun makes it pretty easy to preview detections and a whole host of other things. You just log your data (image frames, rectangles, points, etc.) and it shows up in a GUI that makes it easy to turn on/off different layers. https://www.rerun.io/

The author of egui created https://www.rerun.io/ using... egui but the commercial version is still WIP.

Have you seen emilk's own company, https://www.rerun.io/? All build on top of egui! Check out the webviewer on https://app.rerun.io/. It's all open source, https://github.com/rerun-io/rerun.

It's nearly impossible to have an idea that is truly novel and has no prior art. Even if it isn't the exact same thing, you can see the ideas that inspired this one. All of us are standing on the shoulders of giants all the time. But you've missed a couple of reasons why Rust rewrites are popular. Rewriting in Rust is proven path to better performance (Python codebases pandas -> polars, black -> ruff) or better security. C/C++ codebases like FreeType being rewritten in Rust for security (https://developer.chrome.com/blog/memory-safety-fonts). What should people looking for performance or security do to mollify you? You are asking why aren't completely new ideas being implemented in Rust? They are. Check out https://rerun.io. I could be mistaken, but I haven't seen anything similar to rerun. And that was implemented in Rust. Maybe these aren't visible because there genuinely are so few things that are completely novel.

I am a robotics engineer/scientist and I do shit ton of visualization of all kind of high-fidelity/high-rate data, often in a streaming setting - time series at a few thousand Hz, RGB/depth images from multiple cameras, debugging my models by visualizing many layer outputs, every augmentation, etc. For a long time, I had my own observability suite - a messy library of python scripts that I use for visualizing data. I replaced all of them with rerun (https://rerun.io/) and if you are someone who think Scipton is exciting, you should def try rerun too! I use cursor/vscode for my development and add a line or two to my usual workflows in python, and rerun pops up in it's own window. It's a simple pip installable library, and just works. It's open source, and the founders run a very active forum too. Edit: One slightly related tid-bit that might be interesting to HN folks. rerun isn't that old, and is in active development, with some breaking changes and new features that come up every month. And it means that LLM are pretty bad at rerun code gen, beyond the simple boilerplate. Recently, it kind of made my life hell as all of my interns refuse to use docs and try using LLMs for rerun code generation and come to me with a messy code spaghetti. It's both sad and hilarious. To make my life easier, I asked rerun folks to create and host machine readable docs somewhere and they never got to it. So I just scrape their docs into a markdown file and ask my interns to paste the docs…

Really excited to see Rerun get fleshed out as time goes on. I've used it at $WORK in spare time to visualize multi-agent telemetry and event information for remote operated robotic systems. To me the most useful feature was actually just the timeline view. Being able to see all of the events and telemetry updates from all agents and correlate them to some line plots was already a huge help. I think Rerun should actually make the timeline view just another "view" [0] so that I can have additional timeline views with specific filters. Seeing the discrete pips in the timeline for different events and channel updates is really helpful. Also we already have infrastructure to log and for live telemetry streaming so we don't integrate with the SDK directly in the deployed software and instead just have an adaptation layer to take logs or live data and push it through the Rerun SDK. I generally feel it's better to separate the data generation and logging from the data visualization, though I could understand directly integrating the SDK as a fast solution if the infrastructure is not already there. I hope the use case as the data offload/logging for a system doesn't become a focus sink for the Rerun team. That said, I do appreciate the simplicity of the Rerun SDK API design. At first I wanted to try Foxglove but it seems pretty tied to the supported formats (which we weren't outputting for heritage reasons) and my eyes glazed over when I saw how much work (I perceived) it would…

Rerun is building the data platform for Physical AI, robotics, autonomous systems, AR/VR, and other embodied ML systems. We help engineers log, query, and visualize large, multimodal datasets so they can actually understand what their systems are doing. We started with an open-source Rust visualizer (built with egui, Apache 2.0 / MIT) that’s now used by teams working on real robotics and ML systems. We’re now building out the deeper Rust infrastructure underneath it: data models, storage, indexing, querying, and SDKs. Most of our core platform and performance-critical code is Rust. Here’s more on what we do: https://rerun.io/docs/getting-started/what-is-rerun This month we’re hiring for: - Rust Backend Engineers - Dataframe SDK Engineers - Full-stack Engineer - Customer Portal - Robotics ML Engineer Check all roles and apply here: https://rerun.io/careers

Chrome debugger tools? htop? visidata [1]? Clicker games are interesting in that they start bare and end up filling the screen with controls. Rerun visualizations come to mind too [2]. -- 1: https://www.youtube.com/watch?v=N1CBDTgGtOU 2: https://rerun.io/viewer

Thanks for the shoutout! We did recently add an export for LLMs[1], but weren't quite confident in how the big models handled it. The biggest issue we kept running into was that it would prefer using older APIs over the latest ones. I tested it just now with ChatGPT, and it seems to be doing a lot better! The export is kept up-to-date with the latest contents of our docs, which update every release. Sometimes a bit more frequently, if we're doing drive-by doc fixes. For convenience, here's a GPT pre-loaded with the file: https://chatgpt.com/g/g-674702fde5948191a810bdf73370b6eb-rerun-gpt [1]: https://rerun.io/llms.txt

Is there a public way to add custom Blueprints (https://rerun.io/docs/concepts/blueprint) and Visualizers (https://rerun.io/docs/concepts/visualizers-and-overrides)? It looks like yes for Blueprints, reading through https://rerun.io/examples. I am guessing "not yet" for Visualizers? For example, I'd like to be able to render a Sankey diagram from a "dataflows" Blueprint through the Viewer (https://rerun.io/viewer). I realize that non-spatial is not Rerun's focus.

Custom visualizers are also supported—in fact the graph view started out as an external visualizer. Here is a tutorial: https://rerun.io/docs/howto/visualization/extend-ui#custom-views-class… And here is the corresponding code example: https://github.com/rerun-io/rerun/tree/main/examples/rust/custom_view To write your own graph visualization, you can look into the implementation of our graph view: https://github.com/rerun-io/rerun/tree/main/crates/viewer/re_view_grap… In the future we want to provide more types of layouts, dataflow is high up on that list. May I ask what kind of data you want to visualize? Since you mentioned Sankeys, in your case does the structure of the Sankey change as well, or do you only expect the edges to grow/shrink over time?

There is a native version as well: https://rerun.io/docs/getting-started/installing-viewer You can for instance install and open the viewer natively with just: > pip install rerun-sdk > rerun

You may want to reach out to the PlayReplay team, I saw this post about their work which looks quite cool: https://www.rerun.io/blog/playreplay

here are some pictures, if like me you have no idea what this is: https://www.rerun.io/docs/getting-started/examples