my preprint is on SSRN and i feel somewhat shy to share it here... but the PKU lab's paper that cited mine got accepted by ICML 2026: https://arxiv.org/html/2602.06358v2 submitted by /u/max6296 [link] [Kommentare]

I’ve been working on a mission assurance architecture called Parallax and recently completed another validation run in a degraded operating environment. In this sim run, an autonomous USV fleet experienced GNSS/RF degradation resulting in conflicting navigation observations across multiple assets. Rather than assuming all telemetry was trustworthy, the system continuously evaluated observation integrity, measured divergence from a shared world model, isolated compromised data sources, reconstructed authority through distributed consensus, and maintained mission continuity without operator intervention. One of the problems I’m interested in is what happens after sensor fusion. Most autonomy stacks do a good job combining observations, but what happens when those observations can no longer be trusted? The entire system runs locally at the edge with no cloud dependency. All processing, validation, trust scoring, consensus generation, and decision support remain completely air-gapped and self contained. Current areas of development: • Distributed trust scoring • Reality integrity assessment • Consensus reconstruction • Autonomous recovery and reintegration • GNSS degradation and spoofing resilience • Edge-native operation with no cloud connectivity Interested in hearing how others are approaching sensor trust, degraded navigation environments, and resilient autonomy. submitted by /u/DraevenOfficial [link] [Kommentare]

Been working on a PiCar-X build on a Raspberry Pi 4B. v1 goal: detect an AprilTag (36h11 family, ID 0), steer toward it with a PID controller, drive forward, and stop at a configured distance threshold. Toggle it on from a browser dashboard, 3-second countdown, and it goes. I built this entirely with Claude Code. It’s been a massive productivity boost while balancing a full-time job, and the process of building agentically has been a great learning experience. WebSocket concurrent send corruption The broadcast coroutine and the sensor push loop were both calling send_json() concurrently. At await boundaries they interleaved, Starlette threw, and the client was silently dropped from the send set — meaning the toggle-off confirmation never arrived and the button stayed stuck in active state even after the car stopped. Fixed by replacing the shared client set with a per-connection asyncio.Queue and a single drain task per connection. Camera color inversion that didn't respond to the obvious fixes BGR888 didn't fix it. RGB888 + cvtColor didn't fix it either. Root cause: capture_array() on this Pi hardware returns RGB regardless of the format name, and this platform's libjpeg encodes from RGB input correctly without any conversion. One-line fix once the actual data layout was confirmed via a frame diagnostic log. Had to fully remove Vilib It uses a Picamera2 internal API (allocator) removed in 0.3.36 — crashes on any camera restart after a chase session. Server now owns Picamera2 directly for the full session lifetime. What's next v2 candidates on the list: distance-proportional speed, latching stop behavior, camera tilt tracking, and operator override during chase. Stack: Raspberry Pi 4B · PiCar-X v2.0 · Picamera2 · pupil-apriltags · FastAPI · Python 3.13 submitted by /u/okineedaplan [link] [Kommentare]

I put together a small ROS 2 subsystem that turns a 2-DOF pan/tilt platform and a cheap 2D LiDAR into a stop-and-capture 3D scanner, and figured it might be useful to someone else here. The setup: two Feetech STS3215 serial-bus servos aim an LDROBOT LD19. A node sweeps the platform and an assembler stacks the 2D scans into a `PointCloud2` using the live TF tree. There's an optional MQTT bridge so an external controller (in my case a microcontroller mission queue on a rover) can trigger scans and get a completion handshake back. It's a *complete* project — it even includes a fix to the LiDAR driver (upstream `ldlidar_stl_ros2` won't build on recent GCC/glibc; the patched fork is linked below). It talks to the rover over a well-defined set of MQTT messages, but every command also has an equivalent ROS 2 topic, so if you want a pure ROS 2 setup you just don't launch the bridge. (Personally I love the MQTT side — it lets me drive the whole thing from a tablet.) No vendor SDK — the Feetech STS/SMS half-duplex protocol is implemented directly over pyserial, including handling the URT-1 adapter's habit of echoing every TX byte back on the RX line (the kind of thing that eats an evening if you don't know it's coming). The assembler is driver-agnostic: it consumes standard `sensor_msgs/LaserScan` on `/scan`, so any conformant 2D LiDAR should work. It's running on an RK3588 today and is built to go headless on a Pi 5. This is the first piece I'm open-sourcing from a larger autonomous rover project, GPL-3.0. I'd genuinely welcome feedback — particularly from anyone who's done multi-LiDAR or TF-timing work, since the scan-to-TF synchronization was the fussiest part to get right. But it does work! Happy to answer questions about any of it. Project: https://github.com/aa2mz/pan\_tilt\_lidar Patched LiDAR driver: https://github.com/aa2mz/ldlidar\_stl\_ros2 submitted by /u/CorrectAir8833 [link] [Kommentare]

Can anyone please guide me on how to prepare for Amazon ML Summer School? I’m quite confused about where to start and what topics are most important for the selection process. Any tips, resources, or preparation roadmap would be really helpful. Thanks! submitted by /u/addiemaddieee [link] [Kommentare]

Hi all, A real story from my current experience: I'm associated with an internship where the primary work revolves around autonomous UAVs. What has shocked me the most is that almost everyone is so heavily focused on coding agents and AI tools that they're building things without paying enough attention to the fundamentals. This got me thinking: what if we conduct a virtual session on the fundamentals of Computer Vision? This idea comes from my own experience as well. During my first semester, I was terrified of learning from documentation and kept chasing YouTube tutorials instead. Later, I realized that some of the most interesting and valuable concepts are actually explained in the documentation itself. What do you all think about conducting something like this? How many of you would be interested in joining a one-day session? submitted by /u/FishermanResident349 [link] [Kommentare]

At Foxglove, we collaborated with Aditya Kamath, resulting in another blog post in his ROS 2 LeKiwi series, this time covering the integration of SLAM and Nav2. This blog post should be relevant to anyone wanting to integrate Nav2, even if they don't have a holonomic platform. If you find this kind of content useful, let us know, and we will keep it coming! submitted by /u/arewegoing [link] [Kommentare]

Nature: Outplaying elite table tennis players with an autonomous robot (Published: 22 April 2026): https://www.nature.com/articles/s41586-026-10338-5 YouTube Sony AI: Ace vs. Kihara | Pro Match Highlights | Sony AI Table Tennis Robot: https://www.youtube.com/watch?v=TwkDm2H6ft8 From 链上小财女 on 𝕏: https://x.com/Zoozo2025/status/2064998917394374930 submitted by /u/Nunki08 [link] [Kommentare]

Hey everyone, I am planning out a new open-source infrastructure project and want to get some brutal feedback on the architecture and use-case validity from people running high volume LLM workloads in production. The Problem: Python-based proxies/gateways introduce too much latency overhead for real-time streaming agent steps or fast UI completions. Additionally, centralized semantic caching still suffers from cross-region network latency (e.g., London to us-east-1), and enterprise API costs remain a massive bottleneck for repetitive/predictable user queries (like customer support or structured data extraction). The Proposed Architecture: Instead of a heavy centralized gateway, the goal is to build a lightweight, zero-dependency semantic cache running directly at the CDN Edge using WebAssembly (WASM) compiled from Rust. The flow looks like this: Inbound Prompt: Hits the edge node closest to the user (e.g., Cloudflare Workers / Fastly Compute). Edge Embedding: The Rust/WASM module intercepts the raw text prompt and instantly generates a vector using an edge-native lightweight model (e.g., bge-small-en-v1.5). Similarity Index Check: It performs a fast cosine similarity check against an edge vector database (like Cloudflare Vectorize) to find the nearest semantic neighbor. Cache Hit: If similarity >= threshold (e.g., 0.88), it pulls the full generated response text from an edge KV store and returns it in ~5ms. The main LLM provider is never billed or touched. Cache Miss: It proxies the streaming request to OpenAI/Anthropic/vLLM, streams it back to the client, and asynchronously updates the edge vector index and KV store. Why Rust/WASM? To achieve sub-millisecond execution overhead on the proxy itself, avoid garbage collection pauses, and maintain a tiny memory footprint suitable for edge runtime constraints where traditional databases or Python scripts cannot run. My Questions for the Community: For those running LLMs in production (especially customer support, internal RAG, or autonomous agents), what is your realistic semantic cache hit rate? Is the power law of repetitive queries high enough in your domains to justify this? What are the biggest footguns with semantic caching at the edge? (e.g., Cache invalidation strategies, handling system prompt updates, or drift in embedding models). Would you actually use a drop-in open-source template/CLI that lets you spin this up on your own edge account, or do you prefer centralized API gateways? submitted by /u/Real-Huckleberry-934 [link] [Kommentare]

I had a first go, putting together some of our friends in the space + a bit of research. It’s inspiring to see this vertical grow while everyone complains Europe is dead in tech. You do not need to live in SF or Shenzen to build with robots. You just need good engineers and a high tolerance for pain. There is lot of heavy metal waiting to wake up in Europe. Cyberwave Mirai Robotics Alto Robotics Fluid Wire Robotics Caracol AM ANYbotics Niulinx NEURA Robotics Generative Bionics Pipein Wearable Robotics Enchanted Tools Flybotix Quantum Systems Wandercraft Voliro Exotec Automata Agreenculture Reactive Robotics Verne EasyMile Inbolt https://preview.redd.it/i1ivxo1r1t6h1.png?width=2220&format=png&auto=webp&s=b49920fd224ce5e23121d673f33a78aa8174cecd Who’s missing? Feel free to tag your venture in the comments. Also: I’ll put the link to the database in the comments if anyone wants to contribute to the map and then I’ll happily publish a v2 🫡 Rough visual made with Claude Code can’t wait to see more logos on it. submitted by /u/Erlapso [link] [Kommentare]

I've written a C++ implementation of distilHuBERT. https://github.com/pfeatherstone/hubert.cpp It has no runtime dependencies, the weights are compiled into the library, it supports dynamic sizes, has performance on par with onnxruntime (in my tests) and can be easily integrated into any CMake project. Please let me know your thoughts. submitted by /u/Competitive_Act5981 [link] [Kommentare]