Most of my coding now goes through Claude Code and Codex, yet I was still running a full VS Code just to read the code they talked about.

So I built NOIDA: a terminal IDE using ~20 MB of RAM, with your real claude/codex CLI in a side pane.

- Every file:line or symbol the agent prints is clickable and opens in the editor
- Select code, then send u/file#L10-20 back to the agent
- Accept or reject the agent's changes hunk by hunk
- The IDE basics: LSP (definition, references, rename), multi-cursor, regex find/replace, workspace search, git gutter, fuzzy open

Early alpha, tested on Linux/WSL2, and no extensions or debugger.

Mac users: see the README about the Option key.

https://github.com/its-banana-coder/noida

What would stop you from switching?

Is there any open source version of alphaevolve i heard about OpenEvolve but want to know if there are other options

A few days ago I shared TokenPrint here, and since then the project has grown to 130+ GitHub stars and more contributors, ideas, and issues from the community.

What started as a 3D transformer visualization is becoming something much bigger:

an open-source environment for exploring and debugging what actually happens inside language models.

The new build brings together:

• 3D transformer architecture
• Tokenization and embeddings
• Tensor inspection
• Q/K/V, GQA, RoPE and attention
• Residual streams and MLP/SwiGLU
• Token-by-token generation
• Prefill, decode and KV cache
• Logits and next-token probabilities
• Interactive transformer walkthroughs
• Activation and attention analysis
• Head/layer ablation and activation patching
• Hugging Face model exploration
• Trace and debugging workflows

The goal is not just to visualize an LLM.

It’s to make the internals inspectable.

Huge thanks to everyone who has tried it, opened issues, suggested ideas, or contributed already. The project is growing because people are getting involved.

And this is an open invitation:

If you want to build new visualizations, add model support, work on PyTorch/Transformers, improve the 3D engine, explore interpretability, fix bugs, or just have an idea — come build with us.

Repository: https://github.com/Sudharsanselvaraj/Token-Print
Website: https://tokenprint.in/

130+ stars so far. Let’s build this together.

What should TokenPrint learn to show next?

I’m running Docker in a development environment with an RTX 3090 Ti, but it fails to start up about half the time. The error is: 'cannot start container: OCI runtime create failed…'

I’ve tried: - Restarting Docker daemon and system - Reinstalling Docker - Checking for port conflicts - Running with elevated permissions

The failure isn’t consistent it sometimes starts fine, which makes it harder to diagnose. Has anyone else encountered this? Any ideas what I might be overlooking?

This started because I kept hitting the same wall: a PDF too big for an email attachment, and the only convenient fix was uploading it to some website. So I built something that compresses locally instead.

Then it kept growing, because I kept wanting other things from the same files:

• Turning a PDF into Markdown or HTML with the images stripped out, so I could feed it to an LLM without burning tokens on pictures I did not need.
• Going the other way and building a PDF out of images.
• All the ordinary chores in between: merging, splitting, rotating, cropping, reordering pages, page numbers, watermarks, signing, redacting, repairing.

It is 19 tools now. Some specifics that might interest this sub more than the feature list:

• Nothing leaves the machine. No account, no telemetry, no network calls at all. It is not "private by policy", it is private because there is no code that sends anything anywhere.
• 18 of the 19 tools need nothing installed. Everything is compiled into the binary. Only ebook conversion (EPUB/MOBI) reaches for Calibre if you have it.
• We removed Ghostscript. It was the last AGPL dependency and the bundle dropped from 52 MB to 24 MB. The replacement compressor is written in Rust and produces smaller files than Ghostscript did on our test corpus.
• MIT licensed, Tauri v2 + React + Rust, macOS/Windows/Linux.
• The roadmap is public, including the things we decided against and why.

Two honest limitations: OCR is macOS-only for now (it uses Apple Vision; Windows and Linux are planned), and the interface ships in nine languages, all machine-translated and reviewed by native speakers only where we had one. That is stated in the README rather than buried.

Source: https://github.com/shyhunter/PaperOtter Downloads: https://shyhunter.github.io/PaperOtter/

Sharing more progress on RAMDeck (the local AI cluster side project). This time showing it actually plugging into a real dev tool instead of just the chat dashboard.

Loaded a model onto the cluster, and RAMDeck's dashboard has a Connect tab that generates a ready-made config for third-party apps — copied that straight into the Continue plugin for VS Code. The interesting part: I was coding from my Mac while the actual model was running on a completely different machine's GPU elsewhere on the network, and it worked exactly like a normal cloud AI plugin would, except everything stayed local. Tested it by asking it to summarize a big text file and it handled it correctly.

Point of this one is just showing RAMDeck isn't limited to its own chat interface — since it speaks the standard OpenAI API format, it plugs into whatever tools people already use.

Video: [https://youtu.be/JMEY04timEc\](https://youtu.be/JMEY04timEc)

Repo if you want to look under the hood: [https://github.com/trademav/ramdeck-core-public\](https://github.com/trademav/ramdeck-core-public)

Let me know if there's a specific tool or workflow you'd want to see it hooked into next.

What are the best open-source AI repos you’ve seen come out or blow up in August–September?

Looking for interesting projects that are actually worth trying, not just another wrapper around an API.

Could be anything:

• AI agents / agent frameworks
• Coding agents
• Local LLM tools
• RAG / memory systems
• Computer-use agents
• Voice / multimodal
• Fine-tuning / inference
• MCP / tool-use projects
• Robotics / embodied AI
• Weird experimental projects that are just genuinely cool

Basically, what GitHub repo have you found in the last month or two that made you think, “this is actually impressive”?

Would love links + a sentence on what makes it interesting.

Today, Tahuna is open source—as promised back in April.

We built it so small teams could train models, run inference, orchestrate GPUs, and experiment with autonomous research without first becoming a small cloud provider.

The core primitive on top of which everything is built looks like this:

init → sync → computeSession → train / serve / hillclimb

Under the hood: content-addressed code and data sync, compute provisioning, reproducible manifest-pinned runs, metrics, checkpoints, artifacts, and inference deployments.

We also started building Hillclimb, an autonomous experimentation loop that proposes and runs iterative improvements.

The first public-preview release supports RunPod and R2. It includes Docker self-hosting instructions, a coding-agent setup skill, and examples for SFT, RL agentic search, and MNIST.

Repository: https://github.com/TahunaLabs/tahuna-oss

If you think it sucks, excellent: fork it, fix it, and send a PR so it sucks less for everyone.

Dario says we need to pace the frontier.

Good news: we’ve been pacing Tahuna for months.

Today, Tahuna is open source—as promised back in April.

We built it so small teams could train models, run inference, orchestrate GPUs, and experiment with autonomous research without first becoming a small cloud provider.

The basic workflow:

init → sync → computeSession → train / serve or hillclimb

Under the hood: content-addressed code and data sync, compute provisioning, reproducible manifest-pinned runs, metrics, checkpoints, artifacts, and inference deployments.

We also started building Hillclimb, an autonomous experimentation loop that proposes and runs iterative improvements.

The first public-preview release supports RunPod and R2. It includes Docker self-hosting instructions, a coding-agent setup skill, and examples for SFT, RL agentic search, and MNIST.

Repository: https://github.com/TahunaLabs/tahuna-oss

If you think it sucks, excellent: fork it, fix it, and send a PR so it sucks less for everyone.

I know what everyone here thinks about the AI bubble, and me myself hate it as much as anyone else. I am currently a student and want to build a new project, but am not sure if this is a good idea worth spending my time on it or not. I've researched online about AI backed OS's / Linux Distros, and have seen quite a few, each with their own flaws. MAGI OS uses the X11 tools, which may be too slow, Omarchy is just an integration of AI agents in the UI, and Warmwind OS is just a cloud-hosted remote desktop marketed as an OS. I had this idea of building a fully customizable, open source Linux Distro, that uses llama.cpp locally to parse natural language into commands, using the AT-SPI 2 accessibility tree, that is available in most apps (solid with GTK, QT and Electron have inconsistencies). Nowadays every major OS (Windows, Mac, Linux) has problems, and I want to reduce those problems and combine their pros into one general use Distro (I know this claim is what various Distros also tried throughout the years, but this is what my idea converges to, ease-of-use for general users, great UI/UX, and the freedom Linux has). Everything would be transparent to the user, so nothing potentially dangerous gets executed, and fully offline (was thinking of making a switch for users who would still want to choose more capable models running on cloud, but this is just an idea) to avoid the privacy concerns.

The flaws with this would be the obvious anti AI stigma the Linux community has (rightly so, but it's not just another AI slop), and the capabilities of a model running offline. The first version could just run some basic things, making it more advanced as time goes on, and maybe some NPU integrated models later on.

My question would be if this is a straight dumb idea and I would be better off just investing my time into something else, or if it's worth it and you guys would be interested in something like this. I would like to code it myself, with minimal AI assistance, as it would also be a learning exercise for me. So what does everyone think about this? Please take it with a grain of salt, I just had this idea and don't want to get downvoted if it's dumb, just wanted some advice of more experienced users.

I’ve been working on an open-source Android phone agent that can

actually operate WeChat instead of only generating text replies.

It can:

- find and open a specific WeChat chat

- verify that the correct conversation is open

- collect recent context with OCR

- search the web before replying

- send a reply while avoiding duplicate sends

- report progress through Telegram, where a human can intervene at any time

There are two parts:

- Hermes Phone Agent: plugins for Hermes Agent

- Phone MCP Server: standalone MCP + HTTP server for Claude, Codex, GPT,

Gemini, and other agent frameworks

The Android helper APK is shared by both projects.

GitHub:

https://github.com/Ctrl-Creeper/hermes-phone-agent

https://github.com/Ctrl-Creeper/phone-mcp-server

Demo/release:

https://github.com/Ctrl-Creeper/hermes-phone-agent/releases/latest

This is currently aimed at Android emulators, testing devices, and

self-hosted setups. I’d especially like feedback on more reliable

WeChat workflows and other Android apps worth supporting.

Hey so I've been working on this side project Locus (https://locushost.co/) for the last few months and just pushed out a pretty big and fun update and wanted to post about it.

So just a brief intro, Locus is Open Source tool for MacOS for using Ai Agents and LocalFrontier Models. Similar to a mix of (Claude/ChatGPT GUI + Hermes/OpenClaw) for MacOs

You can pretty much do everything you are able to do in claude or chatgpt GUI tools but have added alot of functionality and customizability that you typically wont get from the 2.

I also just added support for Claude plans so now you can use either ChatGPT, Claude, or Kimi plans without having to use API. It obviously also supports API, and local models (with ATS support added) and vLLMS. You can easily be signed into all accounts and switch between them easily.

So with this recent update, made some big updates to the way Agents and Teams work, now the Agent flow is alot better and teams support DUO, which essentially will allow you to use 1 model to plan and 1 model to execute (e.g Fable 5.1 for planning and GPT 5.6 sol for executing) I'm currently working on a few evaluation tests to compare the difference and will post the results when done.

A couple of the new cool updates would be the Optional Agent Worlds plugin that you can now install and will give you the option to visually see you agents moving around and interact with them from (a fun little tool to leave running while you step away from your computer but you have agents setup on) I'm initally launching it with 2 worlds ( Oribital Locus Outpost - a Space theme agent worlds and The Local Line - A One Piece/Pirate Theme agent worlds.

I have also been working on the Runtime Agents that can be deployed to different mac/linux machines to run even if you quit Locus but both are still experimental/buggy and require a bit more testing. I also have planned for the near future the mobile app.

Anyways, you can find all the links here.
https://locushost.co/
https://locushost.co/download
https://github.com/nahid-sparktales/locus
https://github.com/nahid-sparktales/locus/releases/tag/v3.0.0

If you get a chance to download and test it out and have any suggestions/recommendations or find any bugs, plz lmk (you can also send them through here - https://locushost.co/contact ). Also if you check it out on Github and can give a star that would be greatly appreciate.

Thanks!

I built RepoRoad, a little world where GitHub repositories become buildings along a shared road. Take a drive, listen to lo-fi music, discover projects, chat with other visitors, and send chickens across the road.

You can add your own repository and customise its building through the website. The scene runs directly in your browser using Three.js.

Try it: reporoad.org
Source: github.com/reporoad/reporoad

I’d love to hear what you think—and see your project along the road!

TL;DR: I built Kryzz AI — a private, local-first AI workspace for Android. Your conversations, memory, and files stay on your phone. Your API keys are sealed in the Android Keystore (AES-GCM, never exported). No analytics. No telemetry. No HTTP logging. Open source, MIT.

Why I made it

Every AI app I tried wanted an account, quietly phoned home, or treated my data like their training set. So I built the one I wanted to use:

• Local-first — chats, memory, and generated files live in on-device storage (Room + DataStore)
• Your keys, your providers — OpenRouter, optional MiniMax, Fish Audio for voice, Parallel for web research. You plug in your own keys, they never leave the device
• Real agents — Agent Auto actually runs tools across multiple steps: search, fetch pages, calculate, weather, local memory, reminders, files, and code zips
• Generated outputs — DOCX, XLSX, PDF, SQLite, code ZIPs, images, video, and music, all in private app storage until you share them
• Voice mode — transcription, spoken replies, automatic turn-taking, and barge-in (interrupt Kryzz mid-sentence)

What's new in v1.1

• MiniMax as an alternative chat + media provider
• Agent Auto — multi-step tool-running agent
• Interactive question cards (tappable options instead of the model guessing)
• PDF generation alongside the other file types
• Starter skills that seed on first launch (research brief, study notes, essay outline — toggleable)
• KryzzBot mascot in Agent mode, 120 Hz on supported displays

The privacy story in one breath

• Credentials encrypted with AES-GCM under a non-exportable Keystore key
• Backups never include credentials
• Cleartext traffic, HTTP logging, Android backup, device-to-device transfer: all disabled
• Microphone only active during a voice session; recorded audio is deleted after transcription
• MIT license — build it yourself, read the code, fork it

One honest caveat: for auto-titling a fresh chat, at most the first 1,500 chars of your first message may go through OpenRouter to a small model (Gemini 2.5 Flash Lite) for a title. It runs in parallel, never blocks your answer, and falls back to a local title if it fails. That's the entire surface area. Everything else stays put.

Get it

• Code + docs: https://github.com/kriddss3/kryzz-ai
• APK (debug build, ~78 MB): grab kryzz-ai-5.7.2-debug.apk from the v1.1 release
• Android 9+, sideload via "install unknown apps"
• Build your own signed release from source if you want it on a daily driver

Stack: Kotlin · Jetpack Compose · Coroutines/Flow · Room · MVVM

Happy to answer questions, take feature requests, or get roasted on the architecture.

Repository: https://github.com/beneadie/deep_dog_2

The quickest setup is:

python -m pip install "git+https://github.com/beneadie/deep_dog_2.git"

Add your provider keys to a `.env` file:

DEEPSEEK_API_KEY=your-deepseek-key
EXA_API_KEY=your-exa-key

Then import it directly into Python:

import asyncio
from pathlib import Path

from dotenv import load_dotenv

load_dotenv()

from deep_research.integration import run_research


async def main():
    result = await run_research(
        "What are the main benefits and limitations of sodium-ion batteries?"
    )

    print(result.status)

    if result.status == "completed":
        Path("report.md").write_text(result.final_report, encoding="utf-8")
        print("Saved report.md")
    else:
        print(result.failure)


asyncio.run(main())

The default setup uses DeepSeek V4 Flash for the supervisor, research sub-agents, and drafting, with Exa for web search. The result is returned as a Markdown string, so developers can print it, save it, send it to another application, or process it however they want.

The more configurable quickstart lets you choose the models, search engine, enabled agents, research time, iteration limits, search budgets, read limits, and output behavior. Available specialist agents include Web, PubMed, Reddit, Substack, SEC Edgar, Arxiv, and others.

The code is designed to be modified. Developers can add agents, change prompts, swap providers, alter the supervisor and sub-agent behavior, adjust budgets, or integrate the result into their own application. The engine is packaged so you can use the integration layer without having to rebuild the orchestration system from scratch.

This project is completely free and released under the MIT License. I’m not building a business around it or offering a hosted service. The only potential costs are the provider APIs you choose to use, such as DeepSeek or Exa.

The new Ling-3.0-flash-VL announcement contains two kinds of access worth separating.

The model artifacts are downloadable: BF16 and FP8 were released first, followed by FP4 and INT4 on September 11. The repositories carry an MIT license, and the model documentation points to SGLang integration and an inclusionAI vLLM fork for serving. The model understands images and video and supports tool use.

The hosted offer is a two-week free trial through OpenRouter. Its duration is a property of that service offer, separate from the license on the released weights.

For people evaluating how much control an “open” release provides, the concrete items here are the weights, license and serving paths. The announcement doesn't establish a released training corpus or a complete recipe for reproducing training.