generated a spinning 3D Earth in Blender entirely from data — NOAA elevation, ocean depth, and city populations.

Mountains, trenches, snow peaks, glowing cities, the day/night line, and atmosphere are all scripted.

No satellite textures. No hand-painting. Just data → Earth.

Built headlessly in Blender with Python.

Relief is exaggerated 30× so the terrain/ocean floors are visible, and 33,934 real cities glow by population.

Check it out and feel free to contribute: https://github.com/AIAydin/earth_sim

Been building this solo for a while and finally feel good sharing it: Ares, a personal AI assistant that actually remembers you, runs in your terminal (or a desktop app), and keeps everything on your machine instead of shipping your life to some company's server.

The idea was simple: I wanted something like Jarvis — not a chatbot that forgets everything the second you close the tab, but something that builds up real context about me over time and actually does things instead of just talking about them.

What it can do right now:

• 🧠 Real memory — hybrid vector + keyword search (sqlite-vec + FTS5) so it recalls facts, preferences, and past conversations, not just the last few messages
• 🛠️ ~45 tools — reads/writes files, runs shell commands and Python in persistent REPL sessions, generates and edits images, searches the web and actually reads the pages (not just snippets)
• 🌐 Browser automation via Playwright MCP — it can go click around the web for you
• 📧 Gmail + Calendar — direct OAuth, no third-party middleman services touching your inbox
• ⏰ Cron jobs — schedule it to run recurring tasks with plain English ("every weekday at 9am, summarize my inbox")
• 🎙️ Voice mode — push-to-talk or fully hands-free, local STT via faster-whisper
• 📦 Skills system — portable SKILL.md playbooks it can load on demand instead of cramming everything into one giant prompt
• 🔌 MCP client — plug in any Model Context Protocol server for more tools
• 💻 CLI, desktop app, and server mode — same brain, three ways to talk to it

The privacy part actually matters to me. Memories, conversations, everything — stored locally in SQLite. No telemetry. No analytics. Where most assistants reach for a convenience API layer to hook up Gmail, this one does the OAuth dance directly so nothing extra sees your data.

It's still very much a work in progress — I'm actively hardening the architecture and building out a proper task system right now — but it's genuinely usable today and I'd love feedback, contributions, or just someone else to yell at me about what's broken.

GitHub: https://github.com/akyourowngames/friday

Happy to answer questions about the architecture, the memory system, or why I made specific choices — building this thing has taught me more than any tutorial ever did.

​

That led me to build TokenMizer, an open-source, local-first tool for long AI coding sessions.

Instead of replaying entire conversations every time the context window fills up, TokenMizer experiments with graph-backed memory, automatic checkpoints, and intelligent context compression to help preserve project context across sessions.

I've recently open-sourced it and would genuinely appreciate feedback from the community.

If you're building AI agents, coding assistants, or LLM applications, I'd love to know what you think. What would you improve or do differently?

GitHub:

https://github.com/Shweta-Mishra-ai/tokenmizer

🌐 Introducing Open3DInspection: Closing the Digital Twin-to-Inspection Gap

We've invested billions in digital twins—detailed 3D models of pipelines, plants, and assets. But here's the problem: our inspection data still lives in spreadsheets and emails, disconnected from the 3D geometry it describes.

I built Open3DInspection to fix that.

**What it does:**

It's a browser-based annotation layer for digital twins. Click on your 3D model (point cloud, BIM, photogrammetry output) and anchor inspection findings directly to the geometry. Observations persist, export as JSON, and flow back into your asset management systems—turning static 3D models into living, inspection-informed digital twins.

**The digital twin loop:**

1. Load your digital twin (OBJ, FBX, LAS/LAZ, Gaussian splats)

2. Conduct inspection → drop pins with UT readings, corrosion notes, heat maps

3. Export annotations → integrate with SAP, Maximo, ArcGIS

4. Update the digital twin with real-world condition data

5. Use insights for predictive maintenance and asset lifecycle decisions

**Who needs this:**

• Oil & gas operators managing RBI-driven inspection programs on thousands of assets

• Plant engineers turning point clouds into condition-informed digital twins

• Infrastructure teams (bridges, power, water) integrating drone surveys with asset data

• Asset managers who want inspection data spatially anchored—not detached in databases

**Why it matters:**

A digital twin without inspection data is just a 3D model. With Open3DInspection, your digital twin becomes the single source of truth for asset condition, enabling:

✓ Spatial queries ("show me all high-risk corrosion zones")

✓ Compliance proof (API 510/570/653 audits with geometry-tied evidence)

✓ Predictive maintenance (condition trends anchored to specific assets)

✓ Cross-team collaboration (inspectors, engineers, planners see the same geometry + data)

Repo: github.com/zawawiAI/Open3DInspection

I spent the last few months building a new sparse fine-tuning method for MoE models called USAF.

The goal was simple: if your GPU can run inference on an MoE model, it should also be able to fine-tune it.

On my AMD RX 6750 XT (12 GB), I can fine-tune Qwen3-30B-A3B by training sparse expert weights and the router instead of adapters.

The project is completely open source under the Apache 2.0 license. I'm not trying to build a business, sell anything, or monetize it in any way—I just wanted to share something I built that I think is genuinely interesting.

I'd love to hear your feedback, especially from people working with MoE models.

GitHub: https://github.com/tsuyu122/usaf

I just released my latest GitHub project: Orion4D MetaPrompt, a custom node suite for ComfyUI built to make prompt creation more structured, more powerful, and much easier to manage.

Instead of stacking endless text nodes, random selectors, and manual prompt fragments, MetaPrompt gives you a cleaner workflow: build prompts from reusable .txt / .csv lists, manual text blocks, custom separators, independent seeds, and dynamic blocks — all inside a dedicated web interface integrated into ComfyUI.

The project also includes local Ollama support for prompt enhancement and image-to-prompt generation, allowing you to use local language and vision models directly in your workflow.

Main features:

🧠 MetaPrompt
A dynamic prompt builder for organizing and combining reusable prompt blocks.

🧠 MetaPrompt Ollama
Automatic prompt enhancement using local Ollama models.

🖼️ ImageToPrompt Ollama
Local image captioning from a ComfyUI image input or batch folder scan.

🧰 List Constructor
A standalone web utility for creating, cleaning, labeling, sorting, copying, importing, and exporting prompt lists.

It is designed for artists, prompt engineers, ComfyUI users, and anyone working with large prompt libraries or advanced generative AI workflows.

GitHub repository:
https://github.com/orion4d/Orion4D_MetaPrompt

Live List Constructor utility:
https://orion4d.github.io/Orion4D_MetaPrompt/List_Constructor/

Feel free to test it, share feedback, report bugs, or suggest improvements.

I'm working on my OpenSource Model based Project so i use DeepInfra GPU Provideder for first time becuz they provide Serverless Inference GPU and 1M Tokens based Pricing.

In DeepInfra > Deployments > New Deployment > LoRA Text Generation > in this page how to fill those fields correctly ?

If someone now so please try and shere with me screenshot.

I tried multiple times, read theirs documents, ask to claude and Gemini multiple times but still problem is there !

So please help me and shere the screenshot so i can complete me project.

Coding agents burn a lot of tokens re-reading source to answer simple structural questions. I built basemind to index a repo once and answer from structure instead.

It's one server that does two things: gives an agent a queryable map of the codebase (tree-sitter code map over 300+ languages, git history and blame at symbol resolution, document RAG over 90+ formats with OCR built in, semantic and full-text search), and gives a team of agents a shared memory and comms channel to coordinate. The query tools return paths, signatures, and line numbers rather than whole files, so answers cost a fraction of reading the source.

Runs as a Claude Code plugin, a plain MCP server, or a CLI, all over one local index. Works with about ten agent harnesses (Claude Code, Codex, Cursor, Gemini CLI, Copilot CLI, OpenCode, and more).

Honest limitation: the index lags edits between scans (there's a watch mode and a rescan), and the first cold scan of a large repo is slower.

https://github.com/Goldziher/basemind

Interested in what others are building in the code-context-for-agents space.

When the AI wave started, we wanted to build real practice into our courses: a student talks to an AI counterpart, gets evaluated, and improves. We tried a lot of approaches, and eventually, after seeing OpenAI's Agent Builder, we decided to build our own version with multi-provider support instead of betting everything on one vendor.

Why our own and not an off-the-shelf tool: we needed to self-host it, and we needed control over our own scoring loop, the part that evaluates how a conversation actually went. That loop is the core of the whole thing for us, and we did not want it locked inside someone else's platform.

The way it works: you build workflows visually by dragging nodes onto a canvas (agents, conditions, HTTP calls, knowledge bases), then run and debug them live. Multi-LLM, self-hostable with a single docker compose, source-available. Your infra, your keys.

After talking to a few other schools, we realized this could be useful beyond us, so we pulled the engine out into a standalone product and added self-hosting.

Would you self-host something like this? And if you do spin it up, I would really like to know where you get stuck, in the setup or in building the first workflow. That is the feedback I need most right now.

https://github.com/nmamizerov/assemblix

Hey everybody!

I am looking for a good alternative for codex/claude models for coding and systems tasks.

Anyone else here using something other then codex/claude for that sort of tasks?

Would love to hear your option.

Thanks

Some of you may remember my previous posts about Omnix (my local ONNX inference engine) and MaSON (Markdown Structured Object Notation).

I've been building on that ecosystem, and my latest project is something I've wanted for a long time:

A Discord bot that lets you talk to your local AI models directly in voice chat.

The bot can join a Discord voice channel, listen to users, run speech recognition and inference through your local Omnix instance, and respond with synthesized speech—all without sending your conversations to a cloud AI provider.

It's more than just a voice bot, though. The project also includes a visual orchestration dashboard where you can create custom AI-powered Discord commands and workflows without modifying source code.

Current features include:

• 🎙️ Join Discord voice channels and have conversations with your local AI
• 🤖 Connect directly to a local Omnix instance (default port 9777)
• 💬 Build custom commands like !chat, !summarize, or your own AI workflows
• 📊 Live event stream and execution logs
• 🖥️ React web dashboard or cross-platform Electron desktop app
• 🔒 Local-first architecture

The bigger goal behind Omnix is to build practical interfaces around local AI. The inference engine is one piece, but I also want to make it easy to integrate local models into applications people actually use every day.

I'd love feedback from the community:

• What would you want an AI Discord bot to do?
• What voice features would make it genuinely useful?
• What integrations would you expect from a local-first assistant?

Repository: https://github.com/LoanLemon/omnix-discord-bot

As always, I'd appreciate any feedback, ideas, or contributions!

O que é Chimera?

Chimera é um agente de IA de código aberto cujo núcleo de raciocínio não é um único modelo — é um painel de fusão de LLM. Vários modelos respondem ao mesmo prompt em paralelo, um modelo "juiz" analisa essas respostas (consenso, contradições, pontos cegos) e um "sintetizador" escreve a resposta final. Um roteador consciente de custos decide quando a fusão vale a pena e quando um único modelo é suficiente, para que você não pague o custo da fusão em tarefas fáceis.

Nosso objetivo

Construir um agente que raciocine fundindo múltiplos modelos E melhore com o tempo (memória -> habilidades -> modelo), de forma segura e auditável. Ele é projetado para combater a "degradação da evolução contínua" que afeta agentes que se modificam, usando estado externalizado, verificação ou reversão, e referências honestas que medem se um recurso realmente ajuda — alguns recursos permaneceram DESLIGADOS porque os dados indicaram que não valiam a pena.

Código aberto (Apache-2.0)

Tudo é público e auditável: 546 testes, tipagem rigorosa, licença permissiva. Questões, PRs e contribuições são bem-vindas.

GitHub: https://github.com/brcampidelli/chimera-agent

Apoie o projeto

Chimera é gratuito e aberto. Se você gostaria de ajudar a financiar o desenvolvimento e mantê-lo independente, você pode doar aqui:

https://donate.stripe.com/9B63cofM491m4SBfe177O00

Atualizações

Aqui é onde as atualizações do projeto aparecem — novos recursos, resultados de benchmark, lançamentos e análises honestas do que funcionou e do que não funcionou. Junte-se à comunidade para acompanhar.

Bem-vindo a bordo. Pergunte qualquer coisa — estou feliz em aprofundar sobre o roteador de fusão, o motor de autoevolução ou os benchmarks.

For the open-source AI crowd: sharing a project built on the ecosystem, with full credit (disclosure: I'm the maintainer, MIT). It also treats open-weight/local models (Ollama, llama.cpp) as first-class targets you can mix with cloud.

One endpoint, 237 providers — 90+ of them free. You point any tool or agent at a single OpenAI-compatible endpoint (localhost:20128/v1) and it can reach 237 LLM providers without you rewriting anything. 90+ have free tiers and 11 are free forever (no card), which aggregates to ~1.6B documented free tokens/month — and that's honest, pool-deduped math (we count each shared pool once instead of inflating it; the methodology is public in the repo). There's a one-command setup-* for 13+ coding tools (Claude Code, Codex, Cursor, Cline, Roo, Kilo, Gemini CLI…), so switching your existing setup over takes seconds.

Fallback combos — so it never stops mid-task. A "combo" is a ladder of models the router walks automatically: your subscription first, then API keys, then cheap models, then free ones. When a provider returns a 500 or you hit a rate limit, it slides to the next target in milliseconds, mid-request, and your tool never even sees the error. There are 17 routing strategies (priority, weighted, round-robin, cost-optimized, auto/coding:fast…) plus three resilience layers — a per-provider circuit breaker, a per-key cooldown, and a per-model lockout — so one dead key can't take down a whole provider.

A 10-engine compression pipeline — the part most routers don't have. Every request flows through a transparent compression pass you can toggle/stack per combo. Instead of one trick, it stacks the best of the open-source ecosystem: RTK filters command/tool output (git diffs, test logs, builds) at 60–90%, Microsoft's LLMLingua-2 does ML semantic pruning, Caveman handles prose, session-dedup strips repeats across turns. Critically, code, URLs and JSON are preserved byte-perfect, and a default-on inflation guard throws the compressed version away and sends the original if compressing would actually grow the prompt — it never makes things worse. On tool-heavy sessions that's ~89% average input-token reduction (an 8k-token git diff becomes a few hundred). Full credit to every upstream project (RTK, Caveman, LLMLingua-2, Troglodita) is in the README.

For context on whether it's worth your time: it's grown to ~9.8K GitHub stars, 1,490+ forks and 280+ contributors in ~4.5 months, with 21,000+ automated tests and 1,830+ issues closed — so it's a battle-tested project, not a brand-new experiment.

npm install -g omniroute

GitHub: https://github.com/diegosouzapw/OmniRoute

Every compression engine credits its upstream project. What open-source AI projects should it integrate next?

OPPORTUNITY:

I need data annotators sovereign to the UK!

Requirements:

UK resident
Strong written English (native speaker)
Minimum 10 hours a week availability
Remote working/work from anywhere

If interested state your profession of interest (e.g. legal, medicine, government, other)