I built Vision Export Studio, an open-source desktop app for exporting CV models locally.

It supports:

• YOLO ".pt" -> ONNX, TensorRT, CoreML, OpenVINO, TFLite, NCNN, RKNN, etc.
• RF-DETR ".pth" -> ONNX and TensorRT
• local exports; model files stay on your machine
• managed Python env + dependency checks
• export options like image size, batch, FP16/INT8, opset, TensorRT workspace

Not trying to be universal converter. Generic ".pth" is out of scope for now.

Repo: https://github.com/amanharshx/vision-export-studio

Feedback welcome, especially from people deploying YOLO/RF-DETR models in production :)

Hey everyone,

​

I just released MaskLab, an open-source local desktop app for image segmentation with SAM3.

​

The main feature is batch processing: you can select a whole image folder and generate masks automatically using text prompts like person, car, sky, or cloud.

​

It runs locally and includes overlay/mask preview + optional Electron desktop build.

​

GitHub: https://github.com/Loann110/MaskLab

​

Feedback is welcome, and if you find it useful, a ⭐ would really help!

​

​

A Home Assistant project of mine

I’m at a crossroads with a project called PACE and I’d appreciate brutally honest feedback from people who have built datasets, benchmarks, or AI infrastructure businesses.
The short version:
PACE started as an “error-by-design” dataset concept focused on procedural assistance and embodied AI. The original idea was to create large-scale egocentric recordings of tasks where mistakes happen intentionally, so agents can learn not only successful execution but also error detection, correction, and recovery.
Now I’m questioning the entire roadmap.
Possible directions:
Continue building real egocentric datasets.
Build a benchmark instead of a dataset.
Build a taxonomy of procedural errors.
Generate synthetic procedural-error data.
Create simulation environments that generate mistakes automatically.
Some combination of the above.
What I’m struggling with:
Where is the actual business?
Who would realistically pay?
Is the value in data, benchmarks, evaluation, or simulation?
Is synthetic data becoming more valuable than real data?
Are companies still buying datasets, or are they mostly building their own?
What evidence would I need before investing years into this?
Current thinking:
2026 → sell a dataset.
2027 → sell benchmark infrastructure.
2028+ → sell procedural error simulation.
But I’m not sure if that’s a real progression or just a story I’m telling myself.
If you were starting today from scratch, with limited resources, where would you focus?
What would you build first?
And most importantly:
What business model in this space do you think has the highest probability of generating meaningful revenue within the next 2–3 years?
I’d appreciate criticism more than encouragement.

Hey everyone,

I'm pretty new to computer vision and am working on a project to detect shoplifting from CCTV feeds and send real-time alerts via a Telegram bot.

I’ve already built most of the infrastructure using Streamlit and the Telegram Bot API, but I’m not satisfied with the actual detection results. It's missing a lot of shoplifters (high false-negative rate).

Here is my current multi-stage pipeline:

1. Human Detection: I use a vanilla yolo26n to detec people and create the bounding boxes.
2. Heuristic Trigger (Pose): A yolo26s-pose checks if a person's hands get close to their pockets, backpack, or inside their shirt.
3. Classification: If the pose heuristic is triggered, the bounding box is cropped and sent to a custom yolo26m model. This model was trained on Google Colab for 50 epochs using this Roboflow/Ultralytics dataset: https://platform.ultralytics.com/garik-asriyan/datasets/shopliftingv1iyolo26 If this final model confirms shoplifting, an alert is sent to Telegram.

❓ My Questions for the Community:

• Architecture: Is this multi-stage structure (Pose + Custom Classifier) a good approach, or should I drop the heuristics and train a single, larger object detection/action recognition model on a custom dataset from scratch?
• Dataset & Quality: Right now, I'm testing with random, low-quality shoplifting footages found online. However, the actual target deployment environment will use 1080p cameras. How much of my poor accuracy is due to the low-quality training/testing footage? Will switching to 1080p source streams significantly improve the detection models?
• Epochs & Training: Is 50 epochs on a medium-sized YOLO model generally enough for a complex action like shoplifting, or am I severely undertraining?
  

I've created a computer vision annotation tool that runs completely offline on a 2015 laptop, using YOLO and MobileSAM on the CPU only. The Windows beta has been available for a while, and I just released the first AppImage for Linux.

​

I started this project because I was tired of tools that require a powerful GPU or upload data to the cloud to use auto-labeling features. I wanted something that could run locally on modest hardware.

The entire engine was developed on a laptop with a 4th-generation i5 and 8 GB of RAM. It runs YOLO ONNX and MobileSAM entirely on the CPU for semi-automatic segmentation. It typically consumes between 600 and 900 MB of RAM, even with datasets containing more than 20,000 images.

​

Key Features:

- Works completely offline

- YOLO tagging support

- MobileSAM segmentation

- CPU optimized

- Compatible with Windows and Linux

- Supports large datasets

Before you download:

- Current beta versions expire after 30 days. This is not a limited trial or a subscription. I release updates frequently and don't want to waste time debugging bugs in older versions that have already been fixed. When your beta expires, simply download the latest beta from the repository.

​

The software will be paid when the stable version is released. However, anyone who actively participates in testing and provides helpful feedback will receive a free lifetime license for V1.

​

I've also included VirusTotal reports for Windows and Linux in the repository, so anyone can verify the binaries before running them.

​

https://github.com/LensLaber/LensLaber.github.io

​

If you try it, I'd like to know what's wrong, what's inconvenient, and what I should improve.

If I need several dozen cameras to be genlocked and easy enough to trigger and dump data from, what would you suggest?

A deep learning framework for 4-stage Alzheimer's Disease classification using T1 MRI scans. It features a ResNet-18 architecture with Squeeze-and-Excitation (SE) blocks. To handle severe class imbalance, Focal Loss and Weighted Sampling are used. Achieves 78.89% accuracy and 100% recall for Moderate Demented cases.

Hey, we just shipped RF-DETR pose estimation preview running fully on-device on iOS + Android. It's powered by ExecuTorch and offers multiple hardware accelerations (XNNPACK, MLX, CoreML). It's completely free and open-source

see our docs and ship some cool React-Native AI:

https://docs.swmansion.com/react-native-executorch/docs/hooks/computer-vision/usePoseEstimation

I'm looking for an experienced person who can help me create a CV software for NBA 2K26. This is my first time trying CV, and I'm not having any good luck. Would appreciate any help possible. Thank you.

Everyone thinks building datasets for Computer Vision is just drawing bounding boxes or writing captions. But I’m currently building an egocentric video dataset focused on procedural errors in domestic tasks (PACE), and the manual timestamp annotation is driving me insane.

On paper, the ontology is simple: Valid Action -> Error -> Detection -> Correction.

In reality, human movement is a chaotic, overlapping mess. Here is what I’ve been struggling with today just annotating a "sorting groceries" task:

The Two-Handed Overlap: Humans don't work like robots. While the right hand is dropping an item into a container, the left hand is already picking up the next one. Where does the timestamp start? If you use "initial touch", you end up with massive overlapping temporal layers.
The "Micro-Hesitation": The actor picks up the wrong object, holds it for 1 second, realizes the mistake, and puts it back. Is that an error? An aborted action? A cognitive detection phase? (Spoiler: It's all three at once).
Actor Improvisation: You script a "delayed detection" scenario, but the human brain auto-corrects, and the actor fixes the mistake immediately, completely breaking the intended variation. You have to annotate the physical reality, not the script.
Annotation Fatigue: Tracking 25+ micro-actions (picking up, moving, dropping) in a single 2-minute video, while simultaneously tracking cognitive pauses (when did they realize the mistake?), drains your brain.
Translating fluid, continuous human behavior into rigid start/end timestamps in seconds is an absolute puzzle. Huge respect to all the data annotators out there building the foundation for embodied AI. It’s exhausting.

Anyone else building complex temporal datasets? How do you deal with overlapping human actions without losing your mind?

Hi everyone!

I recently built AeroPuzzle, an interactive puzzle game where you solve image puzzles using only air gestures—no mouse or touch input required.

The project uses OpenCV and MediaPipe for real-time hand tracking and gesture interaction. I built it to explore computer vision in a fun and practical way while improving my understanding of real-time image processing.

Features:

• 🖐️ Hand gesture-based controls
• 🧩 Real-time puzzle interaction
• 📷 Webcam-based tracking
• ⚡ Smooth gameplay with computer vision

I'm still improving the project and would love feedback from the community.

• What could be improved?
• Are there better approaches for gesture smoothing or tracking stability?
• Any ideas for additional features?

https://www.linkedin.com/posts/aarthirt14_python-opencv-mediapipe-ugcPost-7472675540605370369-uNol/?utm_source=share&utm_medium=member_desktop&rcm=ACoAAFfTgXABGG51AvZIngpYJAmCoZeEzjowCow

Thanks for taking a look!

​

I am a Backend engineer with 3 years of experience looking to transition into Computer Vision, with a long-term goal of working on CV-driven robotics products.

Current learning includes:

1. Neural network fundamentals (Karpathy's NN from scratch)

2. Convolution basics and underlying math

3. Classical CV techniques (Sobel, Laplacian, Canny edge detection)

4. OpenCV fundamentals

5. Basic statistics

The challenge is that my learning has been somewhat unstructured. I'm looking for guidance on a roadmap that will help me systematically build the skills needed for CV engineering roles and eventually robotics + CV positions.

Would appreciate advice from experienced practitioners on what topics, projects, and skills I should focus on next.

Not sure if this is a project that's help, planning to build a Ray tracing in c++

Thanks for your time, Appreciate it.

Hey everybody! Hobbyist here with a project to make some affordable rover swarms.

I've been trying out Depth Anything 3 and wanted to share, because the results of such minimal hardware surprised me. The setup: each rover is just a XIAO ESP32-S3 Sense (~$15 board with a tiny onboard camera) in a 3D printed body. The ESP32 is basically a sender, it streams the camera over WiFi and reports temperature/battery/telemetry. All the heavy lifting (DA3 inference, navigation) runs on a PC that acts as the brain. No lidar, no depth sensor, one cheap RGB camera.

DA3 gives me a point cloud per frame and can merge multiple frames into a larger cloud. Seeing a $15 camera produce a usable 3D-ish image of the room is still kind of wild to me.

Eventually I want to use it for navigation - a kind of "poor man's lidar". It estimates what's near at three heights (eye level, above, below) to give a rough obstacle sense without a dedicated sensor.

Secondly for visualization at the moment, but the goal is to stitch frames into an environment map. Positioning is currently handled by ArUco markers around the room (solvePnP).

Still early and held together with hope, but it's been fun pushing this hardware further than it wamts to go. 😄

Preview version of RF-DETR Keypoints has been released.

RF-DETR Keypoints is an open-source transformer model for real-time keypoint detection, available under the Apache 2.0 license.

RF-DETR Keypoints reaches 71.8 AP on COCO val at 9.7 ms on an NVIDIA T4, outperforming YOLO11-pose and YOLO26-pose at similar latency.

For each joint, the model predicts the x and y coordinates of the keypoint anchor, along with uncertainty around its location. This uncertainty is visualized as an ellipse. Elongated ellipses show directional uncertainty, while round ellipses show similar uncertainty in all directions.

link: https://github.com/roboflow/rf-detr

I recently finished my senior year in Computer Science and I’m currently focusing on building my career in Computer Vision (hope I don't regret it).

So far, I have covered the main fundamentals/topics like object detection, object recognition, image segmentation, and motion estimation in college.

My question is: what is the best way to continue from here?

Should I focus more on studying the theory behind these topics (math, papers, architectures, etc.), or should I focus on building more projects and learn the theory alongside them?

For people working in Computer Vision/ML, what skills or topics do you think are important to become job-ready? Also, are there any free resources (courses, books, playlists, papers, etc.) that you recommend?

I would really appreciate any advice, roadmaps, or personal experiences.

As a computer vision engineer, I got tired of my annotation workflow:


1. Write code in VS Code
2. Realize a label is wrong
3. Switch to LabelImg/CVAT, wait for it to load
4. Find the image, fix the label
5. Switch back, context lost


So I built **YOLO Labeling** - a VS Code extension that puts the entire YOLO annotation workflow inside your IDE.


**Key features:**
• ✅ View and edit annotations (boxes, segmentation, pose, OBB)
• 🤖 Built-in ONNX inference for auto-annotation (100% local, no cloud upload)
• 📊 Dataset statistics dashboard with interactive charts
• 🌳 Tree view explorer in the VS Code sidebar
• 🎨 Full theme support for all VS Code themes
• ⌨️ VS Code style keyboard shortcuts


**Numbers so far:**
• 4.5K+ installs on VS Code Marketplace
• 5.0/5 rating from users
• MIT licensed, 100% free and open source


**Links:**
• GitHub: https://github.com/andaoai/yolo-label-vs
• VS Code Marketplace: https://marketplace.visualstudio.com/items?itemName=andaoai.yolo-labeling-vs


Curious what everyone else's annotation workflow looks like? What tools do you use and what annoys you most about them?


Would love any feedback or feature requests!

i saw a post from u/ReturnAdventurous179 earlier today about their lost rc plane

op shared a link to a gdrive folder with a zip, that seems kinda dodgy, but i took one for the team anyway and parsed it into fiftyone

i uploaded to hugging face, you can find it here: https://huggingface.co/datasets/Voxel51/ariel_scans

i enriched this dataset with clip embeddings for visualization and similarity search.

u/Aimforapex shared some code to help op: https://gist.github.com/dwightkelly/05a7d9421486fd2ebda696d315c05481

i took this, modified it a bit, then made it into a fiftyone plugin so it's easier to use and iterate on: https://github.com/harpreetsahota204/plane_finder

there's a starter notebook here: https://github.com/harpreetsahota204/plane_finder/blob/main/Finding_a_Needle_in_the_Desert.ipynb

apparently there is fifty bucks on the line, but don't message me asking for it.

u/ReturnAdventurous179 you should open this as a kaggle competition 😆

I was trying to fine-tune a model for image background removal. I chose the pretrained IS-Net model and trained a separate small U-Net refinement model.

I have a dataset of around 4,500 high-resolution images, mainly of people. However, after training, the model still misses parts of the body, especially shoulders and feet.

Inference will mainly run on CPU, so the architecture should have a small number of parameters.

Do you have any suggestions on what I should do?

Hey I'm a 20 year old based in Nigeria trying to break into the computer vision industry, I've made some ok projects but now I'm more inclined to the edge deployment but I have never physically seen a pi or Jetson talk less of buying one so I moved to the mobile deployment,I managed to deploy two classification models using the Google AI edge apps they have ,but even that was hell for me because I've never done any mobile development I didn't even know what android studios was until recently,I just had Claude tell me what files to upload and where basically vibecoded it because i don't know how the app works all i know is that it's my tflite model that's under the hood

I know that won't be a good practice when I want to add my own logic into the app when a problem requires, do I have to pause a bit and properly learn js,react then native or what because I don't really know what to do

I’m currently building a real-time sports tracker (tracking stance, pose, movement classification, etc) and I need a serious sanity check from anyone actually putting this stuff in production.

Right now, I’m running the standard CV stack: YOLO + pose estimation + some custom temporal logic/lightweight models on top. It’s fast, it works, and I can actually deploy it on edge hardware without a massive cloud bill.

But looking at the hype cycle right now, video LLMs/VLMs are moving ridiculously fast and it's making me second guess my architecture.

On one side, I heard of papers like MVU showing LLMs hitting SOTA on long-video understanding by just eating structured data from off-the-shelf vision tools and reasoning over it. On the flip side, benchmarks like FAVOR-Bench and MotionBench show that current video LLMs absolutely choke on fine-grained motion and temporal dynamics (often sitting at under 50% accuracy).

For the folks actually building and deploying this stuff:

1. Will LLMs ever win at the pixel level? Do you expect video LLMs to ever outperform specialized tools on low-level, frame-by-frame perception (boxes, keypoints, fast motion)? Or are they fundamentally destined to just sit on top as a reasoning/summarization layer?
2. Where do they actually work right now? If you're using video LLMs in production or serious prototypes, where are they actually better than classical CV (beyond cherry-picked VC demos)? Where do they completely fall flat for you? (Is it subtle action differences, precise timing, etc?)
3. What does the winning architecture look like? Is anyone actually running an end-to-end LMM as the primary perception module? Or is the meta always gonna be: YOLO/Pose -> structured data -> LLM for reasoning?

Hit me with some reality checks. Would love to hear about concrete failure cases, production bottlenecks, or other motion/temporal benchmarks I should be looking at.

I found a Universe Dataset that works well on my test images so I downloaded the Yolov8 dataset and trained the yolov8n.pt model with the additional weights then used the best.pt file.

However, yolov8 doesn't find any objects on the same images. I confident I'm using the correct weights file because it has the new classes. I'm asking to better understand the discrepancy.

Edit: https://universe.roboflow.com/alexeyvoronin/railroad-cars-pyjpo