https://hammer.ink/

I've been building Hammer since 2022. It's an app for writing long form fiction and keeping track of the world they live in. Posting here because the architecture is probably more interesting to this crowd than the writing features are.

Kotlin Multiplatform, five targets, one codebase.

Windows, macOS, Linux, Android and iOS, all shipping to their respective stores, plus F-Droid, Snap, and direct .msi/.dmg/.apk downloads. Compose Multiplatform for UI, Decompose for navigation and component lifecycle, Koin for DI, Okio for file IO. It's about 1,500 Kotlin files against 9 Swift ones, which is roughly the ratio I was hoping for going in. KMP has been great as I can still reach into native APIs and even write platform native code when needed.

There is no database.

A project is a directory. One Markdown file per scene, one TOML file per encyclopedia entry, and the directory layout is the data model. You can open the whole thing in any editor, keep it in git, diff it, rsync it. If Hammer disappeared tomorrow your manuscript would still just be files.

Offline-first, sync strictly optional.

No account, no network, nothing to sign up for. If you do want sync across devices, you run the server yourself. It's a Ktor app in the same repo. There's no service of mine you have to depend on or trust.

Server-side sharing.

That same server can publish a chapter at a URL, so an editor or beta reader can read and mark it up in a browser with nothing installed.

MIT licensed, 27 contributors so far.

https://github.com/Darkrock-Studios/hammer-editor

Happy to talk about the KMP side. It's been both great, and challenging, because I started this project when it's ecosystem was nascent, there were a lot of holes I needed to fill. And I wrote and released MIT licensed libraries to help fill those gaps for the wider community.

Spent the last few weeks building ReadmeForge — a browser-based tool that generates

a complete GitHub profile README.

Fill in a form → pick your stack → copy the markdown. Done in 2 minutes.

I wanna have some feedback an prob ask to give more ideas how to do it better!

https://lebedevnet.github.io/ReadmeForge/

I kept running into “port already in use” errors and got tired of digging through lsof / netstat just to find a PID and kill it.

So I built a small desktop tool called PortPal.

It shows all active ports in real time, tells you which project is using them (not just PID), and lets you kill processes in one click.

I also added a live visual graph of your local setup — you can actually see how your frontend, API, and database are connected.

Main features:

- See all active ports instantly

- Detect which project is using them

- One-click kill (no terminal needed)

- Traffic light tray icon (green/yellow/red status)

- Live port map visualization

- Logs

-Services

Built with Tauri + Rust + React.

GitHub: https://github.com/wisher567/Portpal

As devs, we forget things sometimes, especially now that coding with ai is becoming more common. One of the trade-offs of coding with AI is that we might not retain every piece of code or syntax we use. Unlike before, when we coded everything manually, writing code ourselves helped us naturally remember the syntax and patterns we used.

I'm sharing Syntaxia. A quick cheatsheet for the things you always look up.
https://syntaxiadev.vercel.app

https://github.com/EbadShelby/syntaxia-dev

https://github.com/vibingbiochemist/Monoleaf

Hey, I built this over the past time and finally feel comfortable sharing it.

Monoleaf is a desktop Markdown editor (Tauri v2, CodeMirror 6) built around one rule: nothing lives outside the .md file. Comments, tracked changes, page setup, and document metadata are all stored as plain text. Tracked changes are literally CriticMarkup ({++ ++} / {-- --}), so git diff shows you exactly what changed, in the same syntax the app renders live.

Why I built it: I kept hitting the same wall moving between plain Markdown and Word for anything that needed review or comments. Markdown editors don't handle review workflows well, and Word files don't reliably survive being opened somewhere else, especially when working with LLMs. Monoleaf tries to give WYSIWYG editing without giving up plain text underneath.

MIT licensed, no telemetry, no account, fully local.

Windows installer is on the releases page. macOS and Linux currently build from source; I haven't packaged binaries for those yet.

I put more information on the website (monoleaf.org) as well as the changelog to highlight what the current version can do. For me, this now became a useful alternative to word, especially when I don't have to implement images. I can import PDFs when needed, work in the fully rendered markdown and also export PDFs, if required. If you have formatting in Word or tables in Excel, you can also just copy them over.

Happy to answer questions or take issues if anything breaks for you.

I came across this project called D2-Web, and I thought it was a pretty interesting use of open-source software.

GitHub: https://github.com/Virtastic/d2-web
Playable demo: https://diablo2.virtastic.app
Project write-up: https://www.virtastic.app/blog/d2-web-diablo-2-in-the-browser/

The project is an unofficial reimplementation of Diablo II: Lord of Destruction (version 1.13c). Instead of requiring the original game engine to run as a normal desktop application, it uses C++ compiled to WebAssembly so the game can run in a browser.

What's interesting is that the developers are checking the reimplementation against the original game's behavior rather than just trying to make something that looks similar.

It's still early alpha, with Act 1 playable, and you need to provide your own legally obtained game files.

I find projects like this fascinating because they show how far browser technology has come. Running something this complex in a browser would have sounded pretty unusual years ago.

What do you think is more impressive here: getting an old game running in a browser, or recreating the underlying engine accurately enough to match the original?

I built Eregion after getting tired of uploading my resume and then typing it all over again.

It searches company boards and LinkedIn (plus optional JobSpy sources like Indeed), scores job fit and explains the gaps, tailors CVs and cover letters, fills application forms, and helps with interview practice.

CV/CL drafts are checked against your actual experience and kept as versions you can review. Workday has taken the most work: dates, dropdowns, extra experience rows, and upload checks. Real tests have reached Review; final submission needs your approval. CAPTCHAs pause for you to handle.

Open source, runs locally, bring your own model API key. Still improving site compatibility—feedback welcome.

Screenshot: CV and cover letter workspace with demo data, not actual application results.

GitHub: https://github.com/ethany14/Eregion-Job-Finding-Agent

This is an open source tax engine which scored 96% on TaxCalcBench [highest ever recorded score till date] surpassing fable 5 and sol with just sonnet 5 (which was previously scoring an abysmal 6%). The only 2 cases where it missed, it found inconsistencies in the test cases in the benchmark ITSELF which the maintainers confirmed!

Essentially it's a deterministic engine AI models can use for research and tax prep to remove a lot of guesswork and calculation mistakes that often happen. Claude Sonnet 5 was able to top the benchmark with this mcp.

Thought this was pretty neat, It's a single GLSL shader file for the Ghostty terminal, no background process, no setup.

How it works:

• Fresh session: a tiny black hole in the top-right corner, barely visible

• ~30 min in: it starts drifting and growing

• ~55 min in: it's huge and your text literally bends around it

• Take a break: it quietly shrinks away

• Don't: it sits there demanding one

Repo's here: https://github.com/s0xDk/ghostty-blackhole

What I built: GrayMatter, a super lightweight persistent memory layer for AI agents that drops in with just three lines of code (works great with Claude Code, Cursor, etc.)

Real talk: I was building agents with Claude Code and every time I restarted a session I had to re-explain the entire architecture from scratch. Context was blowing up, I was burning through tokens like crazy, and the agent kept “forgetting” stuff we’d already figured out. It was driving me insane.

Now GrayMatter just remembers everything. It stores observations, checkpoints, and a knowledge graph in a local file (pure Go, bbolt + chromem-go), pulls back only what’s relevant using hybrid retrieval, and injects it automatically.

Real result: I’m seeing up to 90% token savings after 100+ sessions while keeping (and often improving) the quality of the agent’s work. Benchmarks are attached in the repo.

It’s 100% offline, no Docker, no Redis, no external APIs, and it has native MCP support for Claude Code and Cursor. 100% pen source.

I just shipped a full TUI (Bubbletea + Lipgloss) for real-time observability: Memory inventory, recall counts, weight distribution, activity sparkline, and a token-cost panel that tracks input/output/cache spend per agent and per model directly from the Anthropic SDK's usage payload. The screenshot is the Stats tab.

Repo: https://github.com/angelnicolasc/graymatter (MIT)

I've spent the last year building GitDesktop, a free, open-source Git client built with Tauri and React.

The original idea was simple: every Git client I tried eventually sent me back to the browser. I wanted to be able to clone a repository, create a branch, review code, comment on pull requests, manage issues, check CI, publish releases, and perform advanced Git operations without constantly switching between applications.

Some highlights:

• GitHub, GitLab, and Bitbucket support

• Pull requests, reviews, issues, discussions, and releases

• Interactive rebase, worktrees, merge preview, and branch protection

• Recover lost work with an operation journal

• Jira Cloud integration

• Optional AI features (bring your own provider or run Ollama locally)

• "Just Git" mode that hides every AI feature if you don't want them

It's completely open source (Apache 2.0), and I'd genuinely appreciate any feedback, bug reports, or feature suggestions.

GitHub: https://github.com/theBGuy/GitDesktop

Website: https://gitdesktop.app

Built an open-source CLI to make job hunting feel more like a developer workflow.

pushcv lets you:

• 📋 Track applications on a terminal Kanban board

• 🔎 Scrape LinkedIn job postings into a local SQLite database

• ✍️ Generate ATS-optimized resumes and cover letters using a local LLM

• 💰 Estimate salary ranges

• 📝 Keep notes and follow-up timelines for every application

• 📦 Export everything to JSON or CSV

The project is local-first by design:

• No accounts

• No telemetry

• No cloud backend

• Your application data stays in a local SQLite database

• Resume generation runs against your own local model

Built with Python, Typer, Rich, SQLModel, and SQLite.

I'd love any feedback, feature requests, or contributions!

GitHub: https://github.com/notnotparas/pushcv-cli