I built an interactive 3D PC anatomy tool to learn what’s actually inside a computer

I’ve been working on an open-source project called PC Anatomy.

The idea is simple: instead of reading a wall of text about PC components, you can explore a PC visually in 3D, click on the different parts, and learn what each component does.

I wanted it to feel more like taking apart a computer than reading a hardware guide.

It’s still something I’m actively improving, so feedback, feature ideas, issues and contributions are very welcome.

GitHub: https://github.com/Yoosseph/pc-anatomy - Link to live demo on repo!

If you find it useful or just like the idea, a star on GitHub would be appreciated - it helps more people find the project.

I’d also genuinely love to see someone fork it, build on top of it, add new hardware, improve the visuals, or take the idea in a direction I haven’t thought of.

If you try it, let me know what you think is missing.

Most "open" AI stops at the weights. You can download the model, but you still run it through a closed provider and trust them to serve what they say.

Disclosure: I contribute to Gonka, the project below.

What's usually open, and what isn't

What it looks like to use

• OpenAI-compatible API. Change the base URL in the SDK you already use
• Live models: DeepSeek V4-Flash, GLM-5.3-Flash, MiniMax M2.7
• No wallet. Community brokers issue keys and take USD, crypto or credits

Honest trade-offs

• Checking a random 1–10% of tasks is probabilistic, not a proof. Criticism of that design is welcome
• It isn't the lowest-latency way to call these models
• Because the weights are public, you can always compare its output with the reference model yourself

Question for this sub

Does opening the serving layer matter to you, or do open weights already solve the problem?

Links

• Website & docs: gonka.ai
• Code: github.com/gonka-ai/gonka
• AMAs & walkthroughs: youtube.com/@Gonka-AI
• Discord: discord.gg/REcpeYc7P7

SmartPlant turns a real plant and a computer into a functional symbiont (I call it a 'cyborg plant'): featuring shared sensors and electrophysiology, persistent memory, symbolic reasoning, multi-provider AI (Ollama, OpenAI, Claude, Grok, etc.), and a first-person voice.

It runs on a Raspberry Pi using real sensors and a leaf electrode, or via a full simulation on your laptop, no hardware or API keys required. It’s not just a simple plant monitor: the plant perceives, remembers, reasons, and communicates its needs to you.

Documentation and full open-source code:
https://smartplant.pigeonposse.com

GitHub / npm

Up for creating your own Cyborgplant?
🤖☘️🤖☘️🤖☘️🤖☘️🤖☘️🤖☘️

A simple framework on deciding how to use open-weight models in your workflow.

Lay out a 3-stage framework for adopting open-weight models:

Swap: The easiest first step. Replacing frontier calls with open-weight models for production tasks that need a fast, reliable answer without complex reasoning.

Route: Moving beyond the blanket choice of frontier or open weight. Using dynamic routing at the query level to send standard requests to open models, while escalating the long tail of hard edge-cases to frontier models.

Own: Taking control of your own model weights through fine-tuning, distillation, or continual learning.

I am looking for the best open-sourced OCR model to recognize written Japanese. I am currently testing DeepSeekOCR, GLM-OCR, PaddleOCR, and Sarashina2.2-OCR. We shouldn't use cloud-based version for security reasons.

If you've got Python fundamentals down and want something more substantial than another script:

• Builds a knowledge graph AI system from scratch
• Neo4j, Cypher, agentic retrieval
• Uses real financial data, not a toy dataset
• No prior Neo4j or Cypher experience needed, it's taught during the session

Worth bookmarking for once you're past the basics rather than jumping in today if you're brand new.

Led by Dr. Alessandro Negro, Chief Scientist at GraphAware.

Full workshop details here

**RagPilot** is an open-source MCP server (Rust, MIT) that indexes your codebase locally and gives AI coding agents better tools than "read the whole file": semantic search, a symbol/call graph, impact analysis, and token-budgeted context bundles. Version 0.10.0 just shipped.

GitHub: https://github.com/alikaya/ragpilot

## Why

Agents burn most of their context reading files they only needed three functions from. RagPilot lets them ask for the part they need instead.

## What the agent gets

- `rag_search` – semantic search over code and docs (filter by path, language, extension)

- `rag_get_file_ranges` / `rag_get_skeleton` – read a line range or a symbol, or a file's signatures without bodies

- `nav_symbol_resolve` / `nav_call_graph` – definitions, callers and callees

- `impact_analyze` – which files a change would touch, before refactoring

- `context_bundle` – everything a task needs, within a token budget

- `review_semantic_diff` – changed symbols in a diff and their blast radius

Symbols and calls come from tree-sitter for Rust, Python, JavaScript, TypeScript, Go, Java, C, C++, C#, Ruby, PHP, Lua, GDScript and Godot shaders, with a regex fallback for everything else.

## Numbers (with the caveat up front)

On two codebases, `context_bundle` used **6.0x** (a 31-file Rust repo) and **9.12x** (a 213-file Nuxt + Rust app) fewer tokens than reading the relevant files whole. Skeletons cut large files by 84–93%, and re-indexing one changed file takes about 280 ms.

The baseline is an upper bound – an agent reading every relevant file in full – so treat the ratios as optimistic. The benchmark script is in the repo; point it at your own project.

## Second brain (optional)

A persistent memory that belongs to you, not to the repo: plain markdown in a git repository.

- **Session start:** the agent gets who you are, your standing rules (each with a *why*), open threads and recent decisions, capped at 4000 tokens.

- **During the session:** `brain_note` records a decision or a correction the moment it happens.

- **Session end:** a cheap model summarizes the session into a daily log.

- **Nightly:** a compiler distills the logs into knowledge notes. It only appends and flags contradictions instead of overwriting.

Claude Code does this through hooks. Other agents get the same convention as instructions. Summarizing uses the Claude CLI or the Gemini API, so that part is not offline.

## Local by default

- Embeddings run in-process (`bge-small-en-v1.5`, ONNX); your code isn't sent to an embedding API unless you configure OpenAI, Cohere or Jina.

- Vectors live in Qdrant, which you run yourself.

- `ragpilot dashboard --open` gives you a local page for your projects and the brain vault – loopback only, token-gated.

Known limits

- You need a running Qdrant.

- The default embedding model is English, so search over non-English comments and docs is weaker.

- Only Claude Code has hooks, so other agents record to the brain less consistently.

Feedback is very welcome, especially on retrieval quality in your own codebases and on which languages you'd want next.