Hello everyone,

I want to share something our team has been working on that may help those of you preparing SPT borehole logs, especially if your office still relies on Excel templates.

GeoEQ SPT Logs is a free Windows desktop application for borehole logging. You enter depths, blow counts, samples, and strata descriptions, and the log sheet draws itself live: soil symbols, USCS classification in bold, the N-value profile, groundwater marker, and automatic pagination for deep borings.

A few things that may be useful in practice:

• Unlimited projects and boreholes in a single file
• Full customization with your own company name.
• Import of existing Excel/CSV sheets — non-standard headings open a column-mapping window, and files carrying only N-values (no blow counts) work too
• One click exports every borehole of a project into a single print-ready PDF with your company letterhead and logo
• Fully offline — data stays in plain files on your machine, nothing leaves your computer
• Two packages: a normal installer, and a portable zip for company laptops where installation is restricted

There's a built-in demo project so you can see a finished log in the first minute.

I would genuinely value this community's judgment on it: what would it need before you'd trust it on a real project? Custom columns (N60, N1(60)), other log formats, different standards? The feature roadmap will be built from what practicing engineers actually ask for.

Download, screenshots and manual: https://github.com/geoeq/SPT-Borelogs

Every disk cleaner I tried just shows you folder sizes. None of them know that cache/huggingface is 20GB of models you downloaded once and never opened again, or that you've got torch installed eleven separate times across old conda environments.

So I built Jharu. It's a desktop app (macOS + Windows) with a knowledge base of 25+ developer and ML cache locations — Hugging Face, Ollama, PyTorch, npm, pip, uv, conda, Cargo, Go, Docker, JetBrains, and more — and it rates each one by how safe it is to delete.

What it does

Splits ML models you've actually used from ones downloaded once and forgotten. Finds every Python virtualenv/conda env and shows how much space is wasted on duplicate packages across them. Scans the whole disk as a treemap so you can see what's actually taking up space, not just guess. Nothing is ever permanently deleted — everything goes to Trash/Recycle Bin.

Apache 2.0, no telemetry, no subscription.

GitHub: https://github.com/riponcm/Jharu

Still early (v0.2.0), so bug reports and PRs are very welcome — especially new cache locations to add to the knowledge base.

Projectmem a small Python tool that keeps a local, plain-text memory of a project's history — the bugs, the attempts that failed, the decisions and why. It all lives in a /.projectmem folder inside the repo, so you can just open or grep every file it writes. It feeds that back to the AI (over MCP for tools like Claude/Cursor, or a plain md file for anything else), and it ties into git so before a commit it can warn you "you already tried this approach and it didn't work. You can ask any question about it.

Github (MIT): https://github.com/riponcm/projectmem

Whether you're a programmer, web dev, researcher, AI coder, or vibe coder: if you work on projects big or small using AI, this can be a real productivity saver.

In the age of coding with AI, fast coding alone isn't enough. Having memory for your project is equally important.

Feel free to ask any questions you have about this tool, I'll try to answer every one of them. Thanks.

Quick story before the project details.

Few weeks ago I watched my AI coding agent confidently suggest the same broken CSS fix I'd rejected the previous Friday. Same contain: layout solution. No memory I'd already tried it. Every new chat was Groundhog Day. That was the breaking point. I'd been trying on a fix for months — this weekend I finally shipped it. It's called projectmem.

What it is:

A small Python package that gives AI coding agents (Claude, Cursor, Antigravity, Codex) persistent project memory through MCP. It captures development events — bugs, attempts with explicit outcomes, fixes, decisions — into plain-text files inside the repo. The agent reads it through 14 MCP tools at session start.

The thing I'm most proud of is the pre-commit hook. It checks your staged changes against memory and warns BEFORE the commit if a logged failed approach exists for that file. Memory plus judgment, at the moment of action. Most "AI memory" tools store and retrieve. Projectmem interrupts you at the right time.

 Tech rundown:

• Python 3.10+, ~600 LOC core
• Deps: mcp, typer, watchdog. That's it.
• Storage: append-only JSONL inside the repo, distilled into summary
• 58 unit tests, end-to-end verified across 4 MCP clients
• 100% local. No cloud, no telemetry, no accounts. MIT.
• v0.1.3 on PyPI, also on the official MCP Registry

What I'd love feedback on:

1. The pre-commit precheck heuristics are simple right now (file-name match → surface failed attempts). What signals would make it smarter without becoming noisy?
2. For anyone running it: did the install + MCP wiring feel clean? What's the friction point?

Genuinely interested in what's working and what isn't for other makers.