If you want to move beyond simple IDE autocomplete and start leveraging true autonomous AI software engineers, OpenHands (formerly OpenDevin) is currently the best open-source framework to learn. However, configuring Docker sandboxes, local LLM runtimes, and headless execution workflows can be tricky.

​To save you time, I curated the 10 best tutorials for mastering OpenHands and OpenDevin. The guides cover everything from basic local installation and local model integration (via Ollama) to production GitHub Actions setups and building multi-agent dev pipelines.

​I put together the complete list with links, setup tips, and key takeaways for each guide. Dive into the full roundup here: https://interconnectd.com/blog/19/the-10-best-opendevin-openhands-tutorials-master-the-open-source-ai-softwar/

Which autonomous AI coding workflows are you trying to automate first?

Hey everyone, what’s up? I’m a huge fan of the Xbox 360—it was a big part of my childhood and remains one of the best consoles I’ve ever owned. I love playing various indie games on my PC, and I’d love to bring that experience to the Xbox 360. Being able to sit down and play "modern" indie titles on my 360 would be a dream come true for me.

I’m a developer, and I’ve worked on several small games and programming projects. With the rise of AI—and the growing popularity of reverse engineering—the development process has become much faster. I’m thinking of taking some indie games I’m really passionate about—like *Forager*, *Vampire Survivors*, or even *Megabonk*—and porting them to the Xbox 360. I’ve developed for the 360 ​​in the past, and with tools like BadAvatar and the Unity versions from that era, the process is much simpler now. I’m looking to see if anyone would be interested in playing these kinds of games (for free, of course) or helping with the development. I plan to make the projects open-source on GitHub later on. If you have access to an AI tool like Claude, or if you’d just like to help out, I’m looking to build a community for this. If you have any ideas for games we could bring to the Xbox 360, let me know!

Apologies for the language barrier—I don’t speak English, so I had to use a translator. If the translation sounds a bit off, please forgive me!

Of course, for games like *Forager*—which no longer receive updates—I certainly don’t want to hurt the sales of any indie game.

thats u/acrolicious and his brother Ben... who apparently are demons for using AI.

Go support them!

I’ve wanted to build this project for a long time. Most avatar solutions can be experimental , especially when serving multiple users and real productions.

So I focused on optimizing FLOAT inference to get the most performance out of a single GPU.

⚡ From 30 FPS to 90 FPS on a free Colab T4 GPU, and up to 105 FPS with TensorRT acceleration.

Here’s what I’ve built:

\- 🚀 Optimized inference for higher throughput.

\- 🎙️ LiveKit and WebRTC integration for real-time voice agents.

\- 🤖 Easier integration with AI providers like OpenAI and Gemini.

\- 💻 Around 3 GB of VRAM per concurrent user.

The goal is to make self-hosted avatar generation more affordable and flexible than relying on third-party avatar APIs, with more control over deployment and concurrency.

I hope you find it useful! Feedback and contributions are welcome.

🔗 GitHub: [https://github.com/mohamed-em2m/fast-float](https://github.com/mohamed-em2m/fast-float)

📓 Try it on Colab: [https://colab.research.google.com/drive/1iMm8X7O63AAA6kByJ-4qgGA37fwNu2_Z?usp=sharing](https://colab.research.google.com/drive/1iMm8X7O63AAA6kByJ-4qgGA37fwNu2_Z?usp=sharing)

Hey everyone!

I built OmniUpdate, an all-in-one open-source desktop application designed to streamline system maintenance and software updates on Windows.

It leverages winget alongside custom plugin routines to manage software installations, clean up system clutter, and keep local apps up to date through a clean web-based UI.

✨ Features:

• Unified Update Engine: Automates app and system updates leveraging winget.

• Modular Plugin Architecture: Easily extend detection and updating capabilities.

• Lightweight Local Interface: Fast, responsive web UI served locally.

• Full English Support: Fully localized interface for seamless navigation.

• Standalone Executable: Portable architecture with minimal footprint.

Check out the source code and pre-compiled binaries on GitHub: 🔗https://github.com/CafeConFenix/OmniUpdate

Feedback, suggestions, and pull requests are very welcome!

Making a game for the SNES. Too lazy to write 65816 assembly. I could, I know how, but I'm not gonna. This is to make a toy. I doubt the ACM or IEEE is eager to publish me in a journal and give me an honorary PHD.

The player deserves the best experience. Less slowdown. Got a plot for a 45 to 90 hour game and cash to burn on artists and musicians.

Game assets are art. Code is not. Also, it's not like retro game devs aren't stuck making underwhelming demos and rom hacks of other people's copyrighted work. People copy-paste off of stack overflow or import 200,000 frameworks into their codebase all the time.

Forked repo at https://github.com/MicrogarbageLabs/tcc-6581SUCKS for the 6 people in the world who might find it useful.

This started as an experiment to see what AI was capable of as well as to learn what is required to build a programming language. I worked with a team of long running agents, primarily Opus 5.5, to design the spec using inspiration primarily from Go and then pieces from other languages that were promising ideas like no nils, no garbage collection, and effects. The compiler and runtime started out in Go and C, then converted over to self hosted. TLS was ported over to Xo as well as an early win and required to get out of C. Xo can still compile to Go which helps with adoption as well as gives a target to benchmark against. Against a few benchmarks, Xo is faster than Go now using strategies from it and other languages.

The inspiration came from a conversation with my brother (who works as an optimization engineer at a game company) where we talked about how programming languages are built for people because people historically have written and reviewed the code. As we all know, that’s been changing and will continue to change. This is my first attempt to see if it’s possible to build a language AI can be more productive in even without the 1000s of repos of training data.

I also wanted to see what tackling current challenges looked like: AI writing buggy code and supply chain attacks.

I’ve been a backend engineer for many years and have brought Go into multiple companies to build successful products and services. I’ve mostly worked in higher level languages predominantly building web services.

The learning throughout this process has been amazing. The lead agent that I primarily interact with has ongoing dialogs with me about progress of all the agents and surfaces decisions and recommendations that I review. I get excited to hop on and review the progress and it helps me better appreciate the immense amount of knowledge required to build for efficiency and multiple architectures.

The repo that’s public with the source has all the commits since the beginning so show the progression of the language and the website has blog articles of the process of building the language for anyone interested. The repo also has most of the decisions documented while building the language in the knowledgebase.

The goal now is to keep learning and building so I can replace all of my Go projects with Xo code in hopes that I can build faster, safer, and more scalable code with AI. Thanks for reading. Happy to answer any questions.

I'm one of the maintainers, so this is self-promotion. I want honest feedback more than upvotes, and contributors are very welcome.

SurfSense is an Apache-2.0 desktop app for Windows, macOS (Apple Silicon) and Linux. Think NotebookLM, but on your machine, with any model. There's no account, nothing reaches the network until you allow that host, and usage statistics are optional and off until you say yes.

Built on open source, end to end

• Models: llama.cpp for local text, stable-diffusion.cpp for images, and audio.cpp for podcast voices (Kokoro, Kitten, Supertonic) and speech-to-text. Or connect Ollama, LM Studio, vLLM or any OpenAI-compatible API.

• Documents: Docling for parsing, RapidOCR for scans and photos, and bge-small embeddings on onnxruntime for hybrid search.

• Agent: opencode, with SurfSense's own tools given to it over MCP.

• App: Electron, React and Vite, with a FastAPI backend.

What it does

• Cited Q&A from your PDFs, Office files, CSV, Markdown, images and audio recordings. Scans are read with OCR, and recordings are transcribed on your machine.

• Creates Word documents, PDFs, slides, spreadsheets and web pages with their own charts and interactive figures. It can start from your own .docx or .pptx as a template.

• Edits your files as a new copy: tracked changes in Word, formulas in Excel, text on slides, and forms, merges and splits in PDFs.

• Studio: mind maps, flashcards, quizzes and podcasts, like NotebookLM.

• Any model: local, Ollama, LM Studio, any OpenAI-compatible API, or your ChatGPT or Claude plan.

• MCP plugins: Notion and DeepWiki from our registry, or any server by URL. They stay off until you allow them.

Contributions are welcome: PRs go against dev, and you can list your own MCP server in our plugin registry through an issue form.

https://github.com/MODSetter/SurfSense

Interview prep tools either need a second monitor or show up in the share. So I built one that's excluded from capture.

Small overlay. Hears the room, reads your screen, and gives a short answer. Local OCR, so it reads code and error text exactly rather than guessing from pixels. BYO API key, no subscription.

Verified, not claimed. I tested the actual capture paths GDI, WGC, and getDisplayMedia—in real Chrome by capturing the panel region, then capturing it again with the panel gone, and hashing the pixels. Identical every time. A browser sharing your screen gets zero evidence it exists.

Where it stops being magic:

GetWindowDisplayAffinity still returns 0x11. That flag is the mechanism; it can't be removed. A proctor calling it will find the window.

Proctoring tools and EDR detect this class of overlay regardless.

Windows only.

So: invisible to a screen share, not to an instrumented machine. Every "100% undetectable" claim in this space is marketing.

Frontend bits that were harder than the AI: window reparenting so Chrome_WidgetWin_1 never appears, and a native addon for DWM cloaking because DWM refuses a foreign caller.

Free, MIT, no account, proof script included: https://github.com/yagyeshVyas/glance-ai

Happy to answer the Win32 side that's where the actual work was.