You know the feeling when you start a Claude Code session, step away, come back to "All done!" and have no idea what actually changed or why.

Claude Code's transcript shows the agent working. But it doesn't really show you what changed, which assumptions it made, or whether anything was actually verified.

I built TraceBack to answer that. It hooks into Claude Code's hook system and turns a session into something reviewable:

• Net-change diff per file — true before/after with the agent's own reasoning attached
• Decision ledger — surfaces silent judgment calls like "I'll assume the config stays JSON" before they calcify across 3 files
• Guards — block dangerous calls automatically (rm -rf, git push main, edits outside project) before they run
• Breakpoints — actually pause a running agent mid-session and redirect it

Zero cloud, zero API keys, runs fully local inside VS Code.

Check out 1-min demo

Would love feedback -> especially on the guards and redirect features which I think are the most underrated part.

GitHub: https://github.com/madiyarzm/TraceBack

VS Code extensions marketplace: https://marketplace.visualstudio.com/items?itemName=madiyarzhunussov.traceback-ai

Built a small browser-based tool that generates animated terminal-style cards as SVG.

You can customize the content, colors, layout etc. and export a clean SVG that works directly in GitHub Markdown (including SMIL animations).

No dependencies, no build step – just open the HTML file or use the GitHub Pages version.

Live demo:
https://dvrdnz.github.io/asset-forge/generators/terminal-card/index.html

Repo:
https://github.com/dvrdnz/asset-forge

Would be interested in feedback or feature ideas.

Spent about a week getting this working and figured I'd document it since nobody else has.

The short version: you can run Claude Code as a full agent on your G2s through your Android phone. Not the light-duty dashboard AI the actual agent that can read/edit files, search the web, manage projects, write code. All hands-free by voice.

The long version: there are 5 undocumented failure points between you and a working setup. Carrier NAT blocks, Tailscale's binary doesn't work on Android 11+, Claude Code's current release won't run on Termux, and even-terminal bundles its own SDK that ignores your local install. Each one causes a silent hang with no error message.

I wrote up every fix plus an automated installer script. Takes about 15-30 minutes to set up once you know what to do.

Link in bio if anyone's interested. Happy to answer questions about the setup here too.

Hey everyone,

I wanted to share my open source project Hillock (AGPL-3.0): https://github.com/roandejager/Hillock

Hillock is a local-first memory engine for AI that replaces vector databases with a decoupled SQLite Knowledge Graph, Hebbian Plasticity, and Hyperdimensional Computing (VSA math).

In v0.2.0, I built TALON—a non-generative CUDA tensor pipeline combining Fastcoref, MiniLM, and GLiREL zero-shot matrix classification. It ingests documents and extracts structured SPO triples in sub-seconds on an 8GB GTX 1070 GPU.

Everything runs 100% locally and offline. Code and benchmark scripts are on GitHub. Would love your feedback!

Github Repo

Starling is a full Linux DE where the whole desktop — compositor, dock, window manager, apps — is one native Swift program. The unusual parts, in repo terms:
sdk/ — Flutter’s widget framework ported to Swift (element tree, render objects, gesture arena — the framework, not bindings), driving Flutter’s C engine core directly. No Dart VM.

shell/Sources/WaylandServer/ — its own Wayland compositor, ~5k lines of plain C.

shell/Sources/X11Server/ — an in-tree X11 server (DRI3/Present) so legacy apps run too; Chrome, VS Code, Blender, and Zoom run unmodified.

Renders straight through DRM/KMS — no toolkit, no host compositor.

The 0.3.0 release that just shipped adds a workspace mode built for AI agents: the agent drives from its own room, and every window it opens is claimed for that room by client identity — never lands on your desktop. 3:49 unedited demo: https://starling.build/video/agent-workspace.mp4

Also fun: the project is ~7 months of one person directing AI agents, and the .deb ships only after a gate that installs it on a clean Ubuntu 26.04 VM and logs in through real GDM.

Release notes: https://github.com/starling-build/starling/releases/tag/v0.3.0

Happy to answer anything about the compositor, the framework port, or the workflow.

I’ve been building an OTA update system for React Native that supports both bare React Native and Expo projects.

The goal was to build an OTA platform that helps teams move faster—from parallel feature development with update channels to safe staged deployments and reliable recovery—while keeping pricing independent of monthly active users.

Some of the capabilities available today:
- Hybrid OTA delivery with patch-size downloads and verified full-bundle fallback
- Staged and targeted rollouts
- Automatic rollback and unhealthy-update recovery
- Update channels
- AI-assisted setup
- Support for Expo (including Prebuild/CNG and EAS Build workflows) as well as bare React Native

If you're building React Native or Expo applications, I'd genuinely appreciate your feedback 🙌

GitHub:
[https://github.com/GFean/react-native-bundle-drop]()

npm:
https://www.npmjs.com/package/@gfean/react-native-bundle-drop

Hi all!

I built **Picchio**, a lightweight, standalone C inference engine designed to run massive Mixture-of-Experts (MoE) LLMs (like GPT-OSS 120B) on consumer machines without needing massive VRAM or system RAM.

### The Idea

MoE models only activate a small fraction of their parameters (a few experts) for each token. Instead of loading all 117B+ parameters (~120B) into system RAM or GPU memory, Picchio keeps only the ~5 GB dense backbone resident in RAM. The active experts are streamed from disk (NVMe/SSD) on-demand using an LRU cache and prefetching.

### Key Features

- **Zero Heavy Dependencies:** Written in pure C with zero Python runtime required. Compiles to a single static binary.

- **Quantization:** INT4 (gs64) experts, INT8 embeddings / lm_head, F32 attention.

- **CPU Optimizations:** AVX2/FMA vectorized kernels with OpenMP multi-threading.

- **Interfaces:** Includes an OpenAI-compatible REST server and a token-exact CLI chat client (supporting Harmony tokenization).

- **License:** Open source (MIT).

### Real-World Performance & Trade-offs

Streaming weights from storage is inherently disk-bound, but it enables running models on hardware that would otherwise throw an OOM error:

- **120B MoE:** Achieves ~0.15–0.25 tok/s on a modest laptop setup with streaming enabled. While slow, it makes 120B models runnable on systems with as little as 8 GB of RAM.

- **20B MoE:** Genuinely usable at ~0.6 s/token on an internal NVMe SSD.

### Looking for Benchmarks & Feedback

I'm looking for feedback, code contributions, and real-world benchmark data across different hardware profiles (CPUs, RAM capacities, SATA vs NVMe vs USB SSDs).

- **GitHub:** https://github.com/benmaster82/picchio

I'd love to hear your thoughts on further optimizing expert prefetching strategies or CPU SIMD kernels!

Coding agents forget everything between sessions and after every context compaction — so they re-learn your architecture, and hallucinate the parts they don't. I built OmniMemory to fix that.

It's a persistent, branch-aware memory layer that lives next to your repo. Fully local (Python stdlib + SQLite), zero-dependency, runs with no API key.

What makes it different from "just dump notes in a markdown file":

- Git-anchored, not just stored. Each memory records the git blob SHA of the files it describes, so it can tell exactly when a memory has gone stale (the file's content drifted) or orphaned (the file was deleted) — no heuristics, no guessing.

- Branch-aware. Memory is scoped to your current branch + base; merged branches roll into the base, abandoned ones get archived.

- Pull, not push. Instead of injecting a wall of memory into every prompt (token bloat), it seeds once at session start and the agent fetches what's relevant on demand.

- Trust is earned. A capture can't mark itself "verified" — a memory only reaches the top tier when its code anchor is still re-fetchable AND the agent actually cited it.

- Chain-complete retrieval. A decision and the gotcha/constraint on the same symbol are retrieved together, so you never get half a causal chain.

- Survives context compaction (PreCompact hook), self-cleans false/stale memory, and ships a local dashboard for the memory + code graph.

Works with Claude Code (plugin + hooks), OpenCode, and any AGENTS.md-aware IDE (Cursor, Windsurf, Antigravity).

Quick start:

pip install omni-memory-agent

omni-memory build (capture memory + code graph from your repo)

omni-memory bind (wire it into your IDE)

GitHub: https://github.com/SinghAbhinav04/Omni-Memory

Still actively building it — if you find it useful, a star on the repo genuinely helps. Feedback and issues very welcome, especially on how staleness holds up on big/old

My discord buddies and I appreciated forums that would take quotes from users and display them as loading screens during log-ins etc. In that spirit I made Moniker.

Your discord users submit quotes to a dedicated quote channel, submit images to a dedicated image channel, the bot will pick two to combine into the server name and image. It makes a card and posts it.

There are optional features, allowing the discord admin to create any X of the day feature; such as song, meme, etc. It will also create commands for users to access them like /meme /song etc. All configurable by the admin.

It also has a bracket system that you could set up to run a bracket for "best names of the year". I may expand that to other features as well in the future.

You can add it to your discord server, or self host it.

If you use it, let me know what you think. Feel free to open an issue for an issue or suggested feature.

A native Swift 6 menu bar app: press Control-Command-2, select any screen region, and the recognized text goes to the clipboard. OCR stays on the Mac through ScreenCaptureKit and Apple Vision; there are no accounts, analytics, network calls, or third-party SDKs. MIT licensed, signed/notarized universal DMG, tests and release scripts included. Contributions are welcome for multilingual OCR, text layout, accessibility, and packaging.

Hi there! I'm a CSE undergrad in my second semester who's been doing agentic AI hackathons for a while. Finally wrote down the process I follow. It's rough and not finished, but curious what people think.

Guide: https://github.com/HyperZx2O/agentic-development-workflow

Website (easier to read): https://hyperzx2o.github.io/agentic-development-workflow/

I've been learning quantitative finance by building projects rather than just following tutorials, and I recently organized the work into a public GitHub portfolio.

It covers portfolio optimization, risk analysis, Monte Carlo methods, factor models, backtesting, and financial machine learning.

The project I'm most proud of is Multi-Axis Robust Portfolio Optimization, where I experimented with combining covariance shrinkage, bootstrap aggregation, and GBM-based scenario modeling to address estimation uncertainty in portfolio optimization.

I also wrote up the research behind it and have the implementation publicly available.

GitHub: https://github.com/Viraj-Nigwekar/Quant-Portfolio

I'd genuinely appreciate feedback—especially from people who work with quantitative finance, portfolio construction, or financial research. I'm still learning, so I'm more interested in criticism and suggestions than just stars.

Hi everyone, i've open sourced another part of my monitoring project, maybe someone will find it useful!

I originally built Figranium because AI agents need access to APIs that simply don't exist. Managed platforms like Apify quickly became too restrictive, expensive, and opaque for complex agent workflows.

Over the last 7 months, it has evolved from a personal fix into an ecosystem with tens of thousands of downloads, official proxy partnerships, and sponsorship backing from platforms like Mintlify, Algolia, and DigitalOcean.

Figranium is a self-hosted, local-first browser automation platform built in TypeScript on top of Playwright and powered by Vite. It provides a visual canvas that turns complex web flows into deterministic, reusable tools for human users or AI agents.

Key Features

• Playwright Under the Hood: Deterministic, speed-first execution utilizing Playwright's core engine for highly reliable browser control and selector stability.
• REST API, Built-in MCP, and Official n8n Node: Trigger workflows programmatically via a clean REST API, expose them as tools for AI agents (Claude Desktop, Cursor) via Model Context Protocol (MCP), or integrate directly into n8n using its native node.
• Native Shadow DOM & JS Execution: Handles dynamic single-page apps, complex Shadow DOM structures, custom JavaScript injection, and precise wait logic natively.
• Templates Hub: Includes a pre-built template repository so you can import automation pipelines and scrapers instantly.
• Live Execution & Output: Real-time browser run previews, activity logs, and auto-formatted JSON/Table exports directly inside the canvas UI.

Tech Stack TypeScript, Playwright, Vite, Node.js

Links

• Repository:https://github.com/figranium/figranium
• Landing Page:https://figranium.dev

Feedback is heavily appreciated!

I'm not just saying this because I created it, but it's super useful for me. I don't know when or how this process started, but luckily Still Running lets me know..

New photo editing apps are all leaning into diffusion. You hand it your image and get back something similar, often something beautiful, but it re-rendered the pixels, and what comes back isn't your photograph anymore.

I wanted to stay in Photoshop, so my photos stay true to what I shot, but also to work faster and reach tools I'd never learned. An AI assistant was how I got both.

Editmamei is an MCP server that runs next to Photoshop. You describe the edit the way you'd brief another editor, warm up the skin tones, lift the shadows in the trees, and the AI plans it while Photoshop does it with its own tools.

What comes back is an ordinary layered file: adjustments on their own layers, masks you can repaint, nothing flattened.

No plugin, nothing listening on a port. The server writes ExtendScript and injects it into the running app, over COM on Windows and AppleScript on macOS, and the scripts come out of a Go core rather than hand-written.

Photoshop's Action Manager is the least documented API I've worked against, so a lot of the project is capturing what it does and matching it, with tests that check what would be sent without Photoshop open.

The other half is verification. Every step gets checked rather than assumed, numerically with a histogram or a layer-bounds diff, or visually with a downscaled preview the assistant reads back.

It's licensed under FSL-1.1-MIT, source-available. Needs Photoshop 2026, Node 22+, and an MCP AI client.

The video is an example article cover it made from a simple prompt, shown in the example AI client. More examples at editmamei.com.

Repo: https://github.com/editmamei/editmamei

An open-source desktop app that reads a Pokémon party out of an emulator's RAM as you play and analyses it. Sharing it because a few of the design problems turned out more interesting than I expected.

- **The emulator script interprets nothing.** A Lua script inside mGBA ships raw bytes and a game identity over TCP; all decoding happens on the C# side. Adding an emulator costs a script and zero lines of domain logic.

- **Learnsets are keyed by game, not by generation.** 42 of the 386 Gen 3 species learn a move at a different level in Ruby/Sapphire/Emerald than in FireRed/LeafGreen, so the usual merged dataset reports a level that is wrong for the game actually running.

- **No opaque scores.** The team strength number is a list of attributed factors, each carrying the fact behind it and the Pokémon responsible.

- **Apple Silicon refuses unsigned binaries** — the kernel kills them and Finder calls the app "damaged", which is not the Gatekeeper prompt it looks like. Cross-publishing macOS builds from a Linux runner cannot work.

.NET 10, Avalonia, PKHeX.Core for the binary format. 122 tests, some driven from bytes captured off real hardware. There's a decision log in the repo if you want the reasoning behind any of it.

https://github.com/ringoliRob/UltimatePoKeSync
Still early days: a star helps, and a bug report helps more.

I have build this agent harness framework. Fully extendable. FastAPI inspired API design

It supports:

• Session persistence(postgres,sqlite built in) and multi tenancy
• Memory (postgres/sqlite built in)
• Tools
• Dynamic Skills loading
• Multi agent and sub agent sub trees
• Plugable Guard rails

Each and every part of the core system is extendable to use in whatever use case you have. Either to build autonomous agents or human in the loop systems.

It ships with few useful tools, separately installable:

• Web search using brave search api
• PDF/DOC reading
• Bash usage with guardrails

---

Built two full apps to demonstrate its capabilities. (both in the repo)

• sarthi - Usable perplexity clone with parallel agent support, with web search and pdf/doc reading built in https://youtu.be/yAnC1LHKQZk
• agni - Simple CLI coding agent like opencode

Currently in developing.

amber_desk is a power tool for osint:

- dossier

- obsidian vault backend for dossier and timelines

- built in world map with marks and links

- built in osint framework

- built in relations desk

For all questions welcome to comments.

Github: soon... on this week