We used RailCompute to connect Codex and automate the full workflow: data prep, training, and model eval with no human in the loop except typing instructions in English.

The aim was to test whether a basic ML workflow could be driven by natural language rather than manually writing the training pipeline or setting up any infrastructure.

The GitHub repo with the detector code and trained model is in the comments.

Built a C++ inference library for RF-DETR, Roboflow's transformer-based object detection model. The motivation was simple, every RF-DETR deployment I came across was running Python and PyTorch at inference time, which is fine for experimentation but not great when you need consistent low latency in production.

The library runs the full pipeline in C++: a fused CUDA kernel for preprocessing, async H2D transfers via pinned memory, and CUDA Graph capture for low-overhead inference dispatch. On an RTX 5070 Ti at FP16 it hits around 2ms per frame for detection and 6ms for instance segmentation.

This release covers both object detection and instance segmentation. Segmentation masks are decoded on the GPU through a custom kernel that upsamples and thresholds all detections in parallel. 

Happy to get any feedback or ideas.

I built "chess-gaze": feed it a chess stream clip; it writes per-frame records for face/eye/head-pose + gaze estimates, then builds a local 3D viewer.

Uses UniGaze, not pupil-center heuristics.

Code, demo.

Some time ago I started diving into ML with Andrew Ng's Coursera course, was quite interesting.

I decided to train a small handwriting model for Georgian (my native language) - current models don't recognize it well - just for fun.

So I started writing letters on paper, taking photos on my iPhone, copying them to my laptop, annotating there, and passing them to the training script. It was very tedious.

I looked for an app that could handle it on the phone - take a picture, annotate in place, export to whatever format. There were a few tools but none fit what I needed. So I thought, why not build the simple app myself.

It looked simple, and it was, nothing complex. But then I was on a train, no internet connection on parts of the route, and it hit me: ah, it should be offline-first. I had to redesign the whole approach - offline-first, sync, conflict resolution. Built that myself too, was an interesting challenge. I now use it for training Georgian handwriting with Kraken, which is an interesting part on its own and something I enjoy.

Then I thought, why not generalize it. Basic idea: a tool for easy collection of domain-specific data that doesn't exist yet. I started it as a single-user thing, then decided to make it multi-user/collaborative - so imagine students sitting in class occasionally photographing handwriting, and all the data gathered in a central place where an admin can review and export it to ML pipelines or other tools.

I also added on-device SAM (Segment Anything Model) to draw polygons around objects automatically, no internet needed.

The tool is simple, the idea's nothing fancy - I started building it for myself and had fun with it. Not sure if there's an alternative out there. I did look and didn't find exactly what I needed: simple tool, take a photo, annotate multiple regions, organize into spaces (organizations) and projects.

It's early alpha, iOS-only for now, up on TestFlight if anyone wants to poke at it. It's rough, critical feedback very welcome.

Curious if anyone else has had to build a dataset from scratch for a niche domain - how did you handle the collecting part?

Hi all,

I was researching anomaly detection with MVTec AD 2 and got confused about the ground truth masks for the wallplug category, especially the overexposed defects.

I am trying to understand the annotation logic. Is the ground truth supposed to mark the visible anomaly spot itself, the whole affected object, or the missing or invalid part caused by the anomaly?

In some examples, the mask seems to mark the visible anomalous spot. In another case, the whole object part seems to be considered anomalous. In image 001, it looks like the mask may be highlighting a missing or hypothetical removed part, but I am not sure, because the shape does not seem to match the expected part very well.

Has anyone else worked with this category and noticed this? Is this a known annotation issue, or is there a logic behind these masks that I am missing?

Images are from the MVTec AD 2 dataset, licensed under CC BY-NC-SA 4.0. I am sharing only small examples for a noncommercial research question, with attribution to MVTec.

I built a small computer vision project based on INSID3, the CVPR 2026 training-free in-context segmentation method using DINOv3.
My version flips the idea: instead of providing a foreground reference, you provide background or normal examples. The algorithm removes background-like regions and segments the remaining object/anomaly.
It supports multiple background sources and can also turn coarse boxes into more precise masks. Other applications are possible like zero-shot anomaly detection.

Would love feedback or test cases: https://github.com/dimfot3/Inverse-INSID3

Hi,

I am currently trying to parse the contents of a virtual F/A-18C Hornet in DCS. For this I utilize OpenCV and with a green channel filter and some thresholding combined with ROI I am able to grab the elements displayed. Template matching is then used for the individual glyphs to extract the value. The only issue is that the pitch ladder turns and sometimes overlays for example the altitude value like here: example

Is there a way to somehow separate the values using CV?

Thank you.

Hey everyone,

We all know SAM 3 is incredible with its visual prompting features, but I recently ran into a pretty frustrating limitation while building out an object detection pipeline. If you want to use a specific visual prompt (like a bounding box of an object in a reference image) to detect that same object across a bunch of other, distinct images, SAM 3 doesn't natively support this.
You can use text prompt but some objects cannot be explained using text prompt.

I spent some time experimenting with workarounds and wanted to share the approach I landed on, plus see if anyone has tackled the next step I'm working towards.

The First Attempt: The "Video Frame" Approach

My initial thought was to hack the video segmentation feature. You can join the images as sequential frames and perform inference through them using the initial visual prompt.

• The Problem: This only works well for actual video or highly sequential data. If your target images aren't extremely visually similar to the reference image, the model rapidly loses context, and the accuracy absolutely tanks.

Current Workaround:

I decided to take a completely different route to force the model to look at the reference and target at the exact same time.

Here is the flow:

1. Take the reference image (containing the object's bounding box).
2. Take the target image (where you want to find the object).
3. Join them side-by-side into a single, unified image.
4. Pass this combined image into SAM 3 along with the original visual prompt.

Because SAM 3 is analyzing it as one single image, it easily finds the related objects across the combined canvas. After inference, it's just a matter of running a quick script to adjust the detected bounding box coordinates back to the original target image's dimensions.

The Results

The results so far have been surprisingly good! I've been running this inference on my current dataset, and it's doing exactly what I need it to. That being said, I still need to scale up my sample dataset size to truly benchmark how robust this is across edge cases.

What's Next: Getting to the Embeddings

While the concatenation approach works, it's undeniably inefficient for large-scale production pipelines. Rebuilding images on the fly adds overhead.

My next step is trying to extract the SAM 3 visual prompt embeddings, store them, and figure out a way to directly inject and reuse them across subsequent images, essentially brute-forcing the native support it currently lacks.

Has anyone here successfully extracted and reused SAM 3 embeddings for cross-image inference? Would love to hear if anyone is working on something similar or has ideas on optimizing this!

code: Link
video: Link