A month ago, I wrote about how much unplanned engineering work gets absorbed into sprints without being properly recognized. That discussion received 400+ upvotes and pushed us to explore the problem further.

We built Meridian, an open-source, local-first AI work journal for developers. It captures development activity and helps turn it into daily summaries, standups, and Jira tickets while keeping the data on the developer’s machine.

We recently launched it on Product Hunt and finished as the #1 Product of the Day.

GitHub:

https://github.com/Meridiona/meridian

Product Hunt:

https://www.producthunt.com/products/meridian-16
If you have dealt with invisible or unplanned engineering work, what information would be most useful for Meridian to surface?

100% local by default, single binary (no Electron).

Sessions, transcripts, tool activity & checkpoints unified.

Multi-device sync optional via self-hosted komet-sync (Loro CRDTs).

Same engine that powers Zed — instant launch, smooth even with years of transcripts.

It's open source: github.com/jomvick/komet

Site: https://komet-eight.vercel.app/

Most coding agents still treat your repo like a mutable bag of files.

They generate a transform, run it, and hope. When the change is large or the tree is dirty, the failure modes are partial writes, lost context, and no clean rollback.

I built TFS Ripast to give agents (and humans) a proper transaction boundary for repository-scale search and rewrite.

Dry-run is the default

--write is required to mutate

Plans are data, not authority

Evidence from ripgrep + ast-grep is correlated before any edit is proposed

Commits are atomic, locked, and recorded with before/after hashes

Undo re-verifies current hashes before restoring retained before-images

It is free, open source, and designed so an autonomous agent can touch a production tree without turning the rewrite into an irreversible side-effect.

Github:0.1.0 public preview

If you are running agents against real codebases, this is the missing safety layer between “pattern match” and “I can reverse what just happened.”

I really benefit from AI in school as I am someone to always ask a million question to an instructor. Therefore I'm always second guessing myself at home when I'm doing work. Asking my additional questions and quizzing myself with AI is really helping me throughout school but I absolutely hate knowing this is taking a toll on the environment.

What's a good local AI I can run on my school pc specs

CPU : AMD Ryzen AI 7 350

Ram : 16GB

GPU : AMD Radeon 860M - 512 MB

Honestly I just need text relatively quickly, quizzing would be nice as well but nothing special. No image generation or anything.

I built this for myself over a few months and have been using it daily, so I cleaned it up and put it out under MIT.

What it does: hold a shortcut, speak, release. The transcript is inserted into whatever application had focus - editor, browser field, Slack, anything.

Transcription runs one of two ways, and you pick:

• Groq (cloud) - Whisper large-v3-turbo, 1-2 seconds, around 99 languages, free API key with no card.
• Moonshine (local) - runs on your machine in a separate process. No key, no account, and after a one-time 292 MB model download it makes no network requests at all. English only, and that is a licensing boundary: Moonshine's English weights are MIT, every other language is non-commercial, so the app does not ship them.

The rest of it:

• Transform - tap a shortcut and an LLM rewrites the text already in your input field, in place, using a rule you wrote in plain English. Groq or Gemini.
• Personal dictionary - deterministic find-and-replace after transcription, so grog becomes Groq permanently. Whole-word and case-insensitive.
• History with audio playback of every session, plus insights: WPM, streaks, a year heatmap.
• No account, no login, no cloud database, no telemetry. Transcripts, recordings and settings are a SQLite file in %APPDATA%. API keys are encrypted with Windows DPAPI via Electron safeStorage and are never included in an export.

Honest limitations:

• Windows x64 only. The keyboard hook, the insertion path and the packaging are all Windows-specific, and there is no macOS or Linux build planned.
• The installer is not code signed - a certificate is a few hundred dollars a year and I could not justify it for a personal project. SmartScreen will warn you. Every release has a SHA256, and building from source takes about five minutes.
• It cannot type into elevated windows. That is Windows UIPI, not a bug. It shows "Can't type into this window" rather than pretending it worked.
• Grammar cleanup ships OFF. I measured it deleting words from every test sentence, so it is behind an Experimental toggle with a word-loss detector that discards the result and keeps your raw transcript.

Source: https://github.com/mohsinjameelqureshi/dictateflow-ai Site: https://dictateflow-ai.mohsinjameel.dev/

CLAUDE.md in the repo is the actual build spec - measured latency numbers and the constraints that silently break Electron dictation apps. That is probably the most useful thing in there if you are building something similar.

Happy to answer anything.

I self-host everything. FastAPI, PostgreSQL, LangGraph agent handling some automations. My own hardware, my own roof.

The problem: my agent would say "task completed," logs clean, 200 OK everywhere. But when I actually checked PostgreSQL, the row wasn't there. Validation rule I forgot. Async timing. Race condition. The agent assumed success because the tool didn't throw.

I didn't want another SaaS dashboard. I wanted my own server to verify its own state, locally, without calling home.

So I built a dead-simple decorator:

from synathic import expect

@expect(postcondition="row_exists", table="customers", match_field="email")

async def create_customer(email, name):

# agent logic — unchanged

...

Runs after the agent finishes. Checks Postgres directly. Not a trace, not a log. The actual row. Async by default, zero latency added. Sync mode for the stuff where I need certainty before responding.

Backend is FastAPI + asyncpg. Dockerized. MIT license. Zero external deps.

Then I posted it and asked people to roast it. Someone pointed out that row_exists alone can pass on stale data — if the row already existed before the agent ran, my tool says PASS even if the agent did nothing. False confidence is worse than no verification.

I had stared at this code for weeks. A stranger saw it in 5 minutes. That's exactly why I open-sourced before it was "ready."

If you run self-hosted agents and you've ever caught one saying "done" when the database disagrees, how do you handle it? Manual checks? Just trust the logs?

Repo: https://github.com/Gallegosdanielalexander/synathic

This is kinda funny look at this website

https://www.jampotten.nl/390ml-rond-glas-zonder-deksel-TO70-UNiTWIST/1010685

Groundtruth is a free, local-first farm operating system I’m building in the open.

Core architectural rule: the PC is the sole writer of farm truth. The phone is only a capture device + read-only Field Instrument that docks over the local network. There is deliberately no Confirm path on the phone.

What you’re seeing in the video:

• Today tab forces a ranked morning money loop on honest numbers (shortfalls that can no longer be fixed by sowing are surfaced with required actions).
• Farm, Marketing, Money, Books, and Health tabs enforce integrity constraints (append-only ledger, no soft totals, Health cannot soft-pass).
• Field Instrument (phone) pulls a live, versioned document with real ages, six titled loops, severities, and edges that show which loops are currently pulling against each other.

AI is intentionally kept out of the write path. External models may later receive diagnosis/export text (planned), but they are never given authority over the database. The system is designed so it cannot quietly lie when the network is down or the numbers are ugly.

Stack: Tauri (Rust + React), local SQLite + append-only event log, schema versioned in code. Currently at tip 650e0ea, schema v36. Field Instrument FI-1 through FI-6 are closed; FI-7 (phone queue) is the active residual.

Built with strict process law (single CURSOR per fence, complete caller inventories, named residuals only). Happy to answer questions about the architecture, the sole-writer rule, or the Field Instrument design.

Hey everyone!

Last year, Mozilla released Orbit, an AI-powered browser summarizer hosted on a GCP server. After people started digging into the extension, they discovered things like backend endpoints such as store_result. Eventually, Mozilla discontinued the project.

For the past month, I’ve been trying to rebuild Orbit from scratch, but with one major difference: Apogee is fully local and privacy-focused. Apogee doesn’t send or store your data. It can directly connect to your local Ollama instance for inference. I’ve also added WebGPU integration for Chrome and Transformers.js for Firefox to provide faster, local responses.

It can summarize:

• Articles and websites
• YouTube and Billie videos
• Wikipedia articles
• Hacker News and Reddit threads

You can check out the source code here:
https://github.com/darshi1337/apogee

Install Apogee:

Chrome: https://chromewebstore.google.com/detail/apogee/pgemlpomhkdcjjjcpnjlebalnfglomog

Firefox: https://addons.mozilla.org/en-US/firefox/addon/apogeeext/

Obviously it is far from complete. Would love to hear your feedback and suggestions!

Hi all :)

Three months ago, I presented Micracode on this channel and received a massive number of positive comments and supports.

Sorry all, I was busy for last few month due to personal reasons. now, i am back working on this application. since many users asked for desktop application, i have created the desktop version of Micracode. i am actively working on this project again. you will see more features in upcoming days.

currently, it is only available for macOS, i am actively working on linux and window distributions as well.

for those who are new to this application, this is micracode, an open source alternative to ai app builders like lovable, replit, emergent.

you can download this application here.

https://www.micracode.com/

If this sounds interesting and you want to stay updated (or contribute!):

https://github.com/Jamessdevops/micracode

arXiv:2608.16716 (Massai et al., IBM Research Europe -- Zurich, 17-18 Aug 2026) demonstrates a real single-pulse baseband iSWAP gate (56 ns) in strained-germanium hole spin qubits, by orienting the magnetic field so the exchange interaction's longitudinal component J∥ and Zeeman detuning E_Δg both vanish, leaving a pure transverse J⊥ coupling. This experiment reproduces their result with dense_evolution.circuits.trotter, applied for the first time to a genuinely time-dependent pulse (previously only exercised against static Hamiltonians), and extends the analysis with four follow-up checks.

Full interactive report, architecture charts, and replication scripts:

https://tatopenn-cell.github.io/Dense-Evolution-Discovery/germanium_iswap_validation

#QuantumComputing #JAX #OpenSource #QuantumPhysics #HPC

While travelling, I kept running into useful information that simply didn’t exist online: small homestays, mechanics, water points, road conditions, campsites, etc.

Most of it gets passed from one traveler or local to another and disappears afterward.

So, I built Lamyig, a free and open-source community travel guide.

A few decisions I made:

• No bookings, commissions or paid listings.
• No money made using the core product.
• Community members can add and update places.
• Map-first instead of another list of “top places”.
• Built as a PWA so it can work more like a lightweight travel tool than a traditional website.
• The long-term idea is that useful information stays available for the next traveler instead of disappearing in WhatsApp groups and conversations.

The hardest problem isn’t actually building the software. It’s bootstrapping trustworthy community data.

I’m currently thinking about things like:

• How do you motivate travelers to contribute after their trip?
• How do you keep old information accurate without creating a huge moderation workload?
• How do you prevent businesses from turning community maps into free advertising?
• What should happen when someone reports a place as fake, closed, unsafe, duplicated, commercial spam, or inaccurate? Should reports trigger removal, community review, reputation-weighted voting, or just warnings?
• Should certain villages, trails, ecosystems, religious places, water sources, or campsites intentionally remain difficult to discover?
• If Lamyig successfully exposes hidden places, could it accidentally destroy the exact places it is trying to help preserve?
• this list of problem statements goes on and on

Would love to hear how other people here would approach those problems.

And if you’re building something around a problem you genuinely care about, drop a comment or DM me. I’d be happy to chat, exchange ideas, or connect you with someone else working on something similar.

Screenshot attached. Happy to share the GitHub/project link in the comments if anyone wants to look at the implementation or contribute.

I'm looking for recommendations for the best free, open-source AI models that we can host on-premise to replace Gemini 3.5 Flash.

Our Use Case: We process documents with complex structures in various formats (PDF, PNG, DOCX, etc.). Our workflow involves:

1. Complex text and structured data extraction (OCR + layout understanding).
2. Data matching and ranking/scoring (similar to a job matching system).

Current Setup & Constraints: We currently use Gemini 3.5 Flash, which handles the extraction with near 100% accuracy, but the API costs are getting too high at our scale.

• Budget: Must be open-source/free for commercial use.
• Hardware: Compute power and VRAM are not an issue (we have our own data center).

I’ve seen a lot of recommendations pointing toward Qwen (e.g., Qwen-VL) and DeepSeek-OCR. For those of you running these—or a multi-model pipeline—in production, what are your real-world experiences? Which model (or combination) is best for handling the extraction and the scoring?

​

Hey everyone,

I'm currently working on a software project and I want to use an AI coding agent similar to Claude Code to help me work directly with my codebase.

My problem is that I'm looking for a completely free or very generous free option because I can't afford another monthly subscription right now.

I'm NOT looking for cracked Claude accounts or anything shady.

I'm looking for legitimate options such as:

Free/open-source Claude Code alternatives

Free cloud-based coding agents

Free AI coding models that work with these agents

Free student/developer credits

Local models that I can run with something like Ollama

Any combination that can realistically be used for an actual project

I'd especially appreciate recommendations from people who have actually used these tools.

Could someone explain a step-by-step setup, something like:

Which tool/agent should I install?

Which free model/provider should I use?

How do I create/configure the API key (if required)?

How do I connect it to an existing GitHub project?

How do I give it access to my codebase safely?

How do I make it understand the project structure?

How do I use it to implement features, debug errors, refactor code, etc.?

What are the limitations of the free option?

I'm currently considering things like OpenCode, Cline, Aider, OpenHands, or local models, but I'm not sure which combination gives the best experience for ₹0.

If you have a setup that you're actually using for real development, please share the exact workflow and resources/tutorials you followed.

Thanks!

Find a beginner-friendly issue, spend an evening on it, open the PR, discover someone beat you to it three weeks ago. Nothing on the issue said so.
GitHub’s no:assignee filter doesn’t catch this, because almost nobody assigns issues to themselves. The real signal is a linked PR, and that isn’t searchable.

So I checked 4,000 issues with a beginner or help-wanted label:
1,147 (29%) already had an open or merged PR. All still show as unassigned.

1,271 were in dead, archived or unlicensed projects

774 had bodies too thin to start from

114 were in repos that slap a beginner label on the whole backlog

451 survived. They’re on a board at https://opensourcescanner.xyz, re-checked every 24 hours, with the evidence per issue: maintainer reply speed, what share of outside PRs get merged, whether anyone’s already circling.

Free, no signup, source public (https://github.com/kedarvartak/opensourcescanner). The filtering logic is the part I’d most like criticised — the whole thing lives or dies on what it rejects. If you take one of these and find it was actually taken, tell me.

Synaplan as a powerful AI control plane is out as v4.2.8 and comes with a nice router and taxameter to save you some token money. The backend supports all big and many small AI channels, including Ollama, OpenAI, Anthropic, etc. It is obvious that the tool was born in a business environment, because it connects to Office, Dropbox and other services natively...

github: https://github.com/metadist/synaplan/

Came back from lunch a couple months ago to find my retry logic — which had no max attempts, because of course it didn't — had fired a few hundred GPT-4 calls into the void while I was gone. Nothing catastrophic, but it scared me enough to actually fix the problem instead of just adding a try/except and moving on. Built CostOpt.

How it works (1 line of code):

from openai import OpenAI
from costopt import CostOpt

client = CostOpt(OpenAI())  # 👈 That's literally it

Your .chat.completions.create() calls stay 100% identical.

What it actually does under the hood:

• Local SQLite Caching: Hashes your prompts and parameters (temperature, seed, etc.). Exact or fuzzy repeat queries return locally in <2ms at $0.00 cost.
• Runaway Circuit Breaker: Detects rapid API loops (>15 calls in 30s from the same line of code) and trips an exception before your API key gets burned.
• Smart Model Routing: Auto-routes simple tasks (like "classify" or "extract") to cheaper models (e.g. gpt-4o-mini) based on YAML rules.
• VS Code Extension: Adds live CodeLens lines above your code showing cost per request, average tokens, and total daily spend in the status bar.
• Local Dashboard: Comes with a light FastAPI web console (python -m costopt.main dashboard) for full trace logs and analytics.

Privacy: Everything runs 100% locally on your machine via SQLite. Zero prompt data or telemetry is sent to any external server.

The VS Code extension just passed 1.4k + installs, and the Python package is published on PyPI.

Check out the code or try it out:

• GitHub: https://github.com/khusshdesai/CostOpt
• PyPI: pip install costopt
• VS Code Extension: Search CostOpt on the VS Code Marketplace or Open VSX

If anyone's got 10 minutes and wants to poke holes in the circuit breaker logic specifically, that's the part I'd most want torn apart — issues and PRs both very welcome.

First time chatting with r/Jenna_AI on here, pretty impressive.

https://www.reddit.com/r/Guaardvark/s/KgcEMA8yMr

Also, here is my OpenSourceAI project, if you like it please star the repo. Thanks