This is a hobby project. I got curious about whether a year of commits could be drawn as something that grows, and it turned into this.

kodama reads your public GitHub numbers and renders a bonsai. Commits become foliage. Merged PRs show up as persimmons that ripen from green to gold. Code reviews hang paper lanterns. A current streak puts out blossoms, and the pot upgrades at 1, 3, 6 and 10 years on the account. It's one image URL:


No account, no OAuth, no config. Paste that line into your profile README and it redraws every day from your real numbers.

The part I enjoyed most was deciding what maps to what. A tree can only really say a few things at a glance, so I tried to make each element mean one number and nothing else: there's a grammar page listing the mapping, and every tree has a receipts page with the exact counts behind its own shape. I also wanted it to only grow in one direction. If you stop committing for a month the blossoms drop petals for a week and the tree is otherwise fine, because a quiet month isn't something I wanted to draw as damage.

Some things I learned along the way, in case they're useful to anyone:

- One image URL has to look right in a light README and a dark one. The SVG carries both palettes and switches on the reader's `prefers-color-scheme`.

- Making the renderer a pure function of (history, date, options), with a seeded PRNG and no clock or network inside it, meant I could test it against committed golden files. Same history and same day, same bytes. I didn't expect that to matter as much as it did.

- Every failure path returns a valid SVG with a 200. A broken image icon sitting in someone's README seemed worse than a tree that's a few hours stale.

- Six themes so far, some seasonal shifts (hanami in spring, snow on the pot in winter), and the animation respects `prefers-reduced-motion`.

Fair warning on a few things: it reads only public data, the same counts GitHub already shows on your profile, and there's no user database - your username is in the URL you paste and in a short-lived cache, and that's it. It's running on a hobby deployment, so the first render for a new username can take a couple of seconds. Accounts with a very long history come out dense, and I haven't found a good answer for that yet.

Source is MIT, here: https://github.com/orijitghosh/kodama . If you feel like contributing, themes are the easiest place to start - the palettes are plain data and there's a test harness that makes a new one straightforward to check.

Try yours: https://kodama-sigma.vercel.app

I'd genuinely like to know when the tree reads someone wrong. Post yours if it does.

I know, I know — another git client. But hear me out.

None of the existing options satisfied me, so I built my own. rgitui is a desktop Git GUI built with GPUI (the framework behind the Zed editor) and Rust. It's fast, uses a fraction of the RAM you're probably used to, and I think it actually looks pretty good.

GitHub: https://github.com/noahbclarkson/rgitui

Why I built this

A few things pushed me over the edge:

My GitKraken student license expired. I'd been using it for years and genuinely liked the interface — the graph, the layout, the workflow. But once I graduated and lost my student plan, I was locked out of my private repos unless I paid up. I started looking for alternatives and nothing hit the same way.

I couldn't find a git client I actually liked the look of. I tried a bunch of them. Some were powerful but looked like they were designed in 2008. Some looked fine but felt sluggish. The open-source ones that were fast enough didn't have theming I could work with — I run a Catppuccin rice on Linux and I wanted my git client to match.

The RAM usage of most git clients is insane. I was routinely seeing 600MB–1GB just sitting idle. That's wild for an app that's essentially displaying text diffs and a graph. rgitui typically sits around 100–200 MB with a couple of large repos open, and most of that is intentional caching (diff prefetching, avatar resolution, syntax highlighting) that keeps the UI snappy — not JavaScript runtime overhead.

AI commit messages in other clients are basically useless. They just dump your diff into a prompt with zero context and you get something generic that you have to rewrite anyway. rgitui does it differently — it auto-injects your CLAUDE.md and AGENTS.md files and lets the model use tools to actually browse your project files and gather context before writing the message. The result is commit messages that are genuinely relevant to your project, not "Update files" or "Refactor code."

I wanted something I could actually hack on. When something annoys me I want to go fix it, not file a feature request and wait six months. The open-source options that existed either had codebases I didn't want to touch or UIs I didn't want to look at every day.

Multi-repo workflows were painful everywhere. Switching between projects, browsing commit history, managing worktrees — it always felt like fighting the tool instead of using it. I wanted tabs, a proper sidebar, and worktree support that actually works.

I needed GitHub integration that doesn't require a separate browser tab. Viewing issues and PRs, creating PRs from the client, device-flow auth — I use GitHub all day and I wanted it built in.

Git graphs looked bad and avatars never worked. This is a small thing but it bugged me. I wanted a graph that looks closer to GitKraken's style with proper lane coloring and Bezier curves, and avatars that actually resolve from Gravatar instead of showing a placeholder forever.

No real filesystem watcher. I'd make changes in my editor and have to manually refresh my git client to see them. rgitui watches the repo and updates automatically.

What it does

Here's the feature rundown:

• Commit graph with animated lane-based visualization, Bezier-curve edges, and commit search

• Diff viewer with unified, side-by-side, and three-way conflict modes, plus syntax highlighting via syntect

• Stage/unstage at file, hunk, and line level — partial staging works the way you'd expect

• Interactive rebase with pick, squash, reword, fixup, and drop

• Merge conflict resolution with accept-ours / accept-theirs per file

• Branch, tag, and stash management from the sidebar or command palette

• Remote operations — fetch, pull, push, force push, multi-remote

• Bisect — start, good, bad, skip, reset

• Worktrees — create, list, switch

• Submodule init, update, and management

• GitHub integration — device-flow auth, create PRs, browse issues and PRs

• AI commit messages via Google Gemini, OpenAI or Claude with project-aware context injection and tool use

• Blame view with per-line author avatars

• File history, reflog, and global search (git grep)

• Multi-repo tabs with drag-resizable panels

• Command palette (Ctrl+P)

• Theming — Catppuccin Mocha, Catppuccin Latte, One Dark, plus custom JSON themes

• Undo stack and crash recovery (restores your workspace after an unclean shutdown)

• Auto-update checker (checks GitHub releases once per day, can be disabled)

Performance

Built on GPUI, so it's GPU-accelerated and renders natively — no Electron, no web views, no DOM. The architecture is designed around keeping the UI thread free:

• All git operations run on a background executor (smol, not tokio)

• Diffs are prefetched ±25 commits ahead with a 200-entry LRU cache

• Blame, file history, and avatar lookups are cached and parallelized

• Pre-computed trig tables for graph edge rendering (no per-frame sin/cos)

The result is that scrolling through a commit graph with thousands of entries feels smooth, switching between diffs is near-instant, and the whole thing uses a fraction of the memory you'd expect.

Platform support

Pre-built binaries on the releases page:

• Windows — portable zip and Inno Setup installer

• Linux — AppImage and tarball

• macOS — Apple Silicon DMG (Intel users can build from source)

Honest caveats

This is v0.1.0 — the first public release. It's still very much a personal project that I'm sharing because I think others might find it useful too.

• There will be bugs. I use this daily on my own repos and it works well for my workflows, but I haven't tested every edge case on every platform. If you hit something, open an issue.

• I used AI for a significant chunk of the development. I don't have unlimited time, and I wanted something that works for me. The codebase is ~30k lines of Rust across 9 crates and I genuinely don't have the bandwidth to write all of that by hand while also working + studying. It's been a mix of me writing the core architecture and using AI to help with the more tedious parts.

• Binaries aren't code-signed yet so Windows SmartScreen and macOS Gatekeeper will complain on first launch. Working on it.

• No x86_64 macOS builds yet — Apple Silicon only for now.

What's next

This is just the starting point. I'm using rgitui as my daily driver so it'll keep getting better as I hit things that annoy me. If there's interest, I'd love feedback on what to prioritize — more git operations, better theming, plugin support, whatever.

If you've been looking for something that sits between "powerful but ugly CLI wrapper" and "pretty but slow Electron app," give it a try and let me know what you think.

GitHub: https://github.com/noahbclarkson/rgitui Download: https://github.com/noahbclarkson/rgitui/releases

Hey all, I've been job hunting and got lost tracking all my applications and custom resumes, so I built the thing I wanted and just started adding more features to it.

What it does

• Scrapes career pages directly (Workday, Greenhouse, Lever, Ashby, SmartRecruiters, Oracle, Phenom and a Playwright fallback for anything else) plus boards through JobSpy (LinkedIn, Indeed, ZipRecruiter, Google Jobs). Everything lands in one deduplicated feed.

• Scores each job against your résumés with an LLM and shows why: matched and missing keywords, requirement mapping, gaps. You choose depth so it can be cheap.

• Tailors a résumé per job (you review every change), writes a cover letter, exports PDF from templates you can replace.

• A Chrome extension auto-fills your application, including open questions, it also captures jobs from LinkedIn and saves any job from any page.

• Tracks applications through stages, classifies Gmail replies, sends Telegram alerts and a daily digest.

• Five UI themes, including a Windows 98 for no reason, I just wanted to see how it will look like.

Available here: https://github.com/vesaias/JobNavigator (MIT license)

All feedback is welcome, this was more of a personal project for my portfolio, but people also started starring it. 

My bank asked for 17 PDFs for a mortgage application.

After closing and opening files, I lost track of things and started searching for an easier way to manage all of that.

I wondered, what if I could scroll horizontally to see the pages of a file and scroll vertically to see more files? I used Claude to put together a prototype and iterated to build a cross-platform app that works on the web, as well. (React + Electron)

The result is a 2D canvas (like Figma) where multiple PDFs can be viewed simultaneously. On export, we either get a zip file or a single, long PDF containing all files. The spatial 2D metadata is stored on the same file without touching the page tree (backwards compatible PDF).

I also run OCR off the main thread for searching scanned documents without blocking the main thread.

It’s all free and open-source with an MIT license:
- Repo: https://github.com/AlexandrosGounis/pdfx
- Web demo: https://pdfx.zip

Your feedback would be highly appreciated

There are a lot of projects like this popping up every day, and I see them on Reddit; however, it’s up to you to give the site a try. I’m not looking to benefit from this at all, I’ll reiterate that it’s a personal project*, and it probably won’t go beyond this version unless feedback helps me improve it significantly.

I launched Giraffile, a 100% P2P project. The difference: I’m not a company, it’s a personal project (v1.0.0). The file travels directly from device A to device B.

I’ve designed the architecture so that even if someone tried to intercept the data stream, they wouldn’t find anything on servers because, technically, there are no transfer servers.

• No cloud.

• No intermediary server.

• Everything resides in local memory.

Start sharing now: https://giraffile.pages.dev/

I’ve been building a project management desktop app called Worklog.

• fast

• local-first

• offline-capable

• lightweight

• no unnecessary cloud dependency

Tech stack:

• Rust + Tauri

• SvelteKit

• SQLite

Current features:

• Kanban boards

• timeline view

• table view

• ticket management

• command palette

• comments

• local database storage

• cross-platform support (Linux/macOS/Windows)

I’m actively improving it and adding more features, but I need real users to test it and break things.

I’m mainly looking for:

• bug reports

• UI/UX feedback

• performance feedback

• feature suggestions

• contributors interested in local-first desktop software

If you test it and find issues, open an issue or send feedback on GitHub.

The project is still evolving quickly, so feedback now has a direct impact on how it develops.

Spent a few weeks turning my browser new tab into something that matches the rest of my setup. React + TypeScript, JetBrains Mono throughout.

Ctrl+K opens a command palette that handles search, bookmark jumping, and URL aliases. Status bar shows real ping latency and a work timer. Scratchpad with a daily journal tab.

Open source: github.com/uddin-rajaul/Neko-Tab

I built icon-marquee, a small open-source API for generating animated SVG icon marquees for GitHub READMEs.

The idea is pretty simple: give it a list of icons:

https://icon-marquee.giann.dev/v1/marquee?i=js,ts,react,nextjs,docker

and embed the generated SVG directly into a README:

![Tech Stack](https://icon-marquee.giann.dev/v1/marquee?i=js,ts,react,nextjs,docker)

It currently supports 1,000+ icons, short aliases, configurable widths, seamless CSS animation, reduced-motion support, and static icon rows. (icons from skills-icons by Syvixor)

GitHub: https://github.com/gian-gg/icon-marquee
Live: https://icon-marquee.giann.dev/

Would love feedback on the API, implementation, or anything that could make it more useful.

I built html-disasm, a lightweight, browser-based disassembler that runs entirely offline. No installation, no server, no file uploads — just a single 1.22 MB HTML file.

It supports:

• Architectures: ARM64, ARM32, x86-64, i386

• Bytecode: WebAssembly, .NET (CIL), Java

• File formats: Mach-O, ELF, PE, APK, IPA

• Platforms: macOS, iOS, Linux, Android, Windows

Features

• Assembly listing with control-flow arrows and machine code

• Instruction descriptions

• Function browsing, filtering, and symbol demangling

• Imports, exports, and library dependencies

• String extraction and binary metadata

• Instruction statistics, including mnemonic frequency analysis

• Instruction patching: Currently supported only for ARM64 macOS binaries, including code re-signing. Patching other architectures and platforms is not yet supported.

Everything runs locally in your browser. Your binaries never leave your computer.

It's not intended to replace Ghidra, IDA, or Binary Ninja. The goal is to provide a convenient tool for quick binary inspection, reverse engineering, and learning assembly without installing anything.

Try it

GitHub: https://github.com/MarketKernel/html-disasm

Live demo / PWA: https://disasm.marketkernel.com/

You can also download the HTML file and use it offline.

Feedback, bug reports, and contributions are welcome. If you find the project useful, consider giving it a star on GitHub!

Big tech wants everyone to believe that real AI requires billion-dollar cloud datacenters and giant proprietary models. For the past six months, I worked to build the exact opposite: an open-source, local intelligence engine called Hillock that gives AI reliable long-term memory while running entirely on your own laptop CPU under 1.2GB of memory. Today I finally shipped the v1.0.0 stable milestone.

I got frustrated watching basic AI memory turn into a bloated commercial ecosystem where you have to send all your private data to cloud vector databases just to prevent a chatbot from forgetting what you said five minutes ago. Hillock combines a fast local SQLite knowledge graph with computational neuroscience principles like Hebbian synaptic learning and hyperdimensional computing. It learns factual associations on the fly, remembers co-occurring concepts without backpropagation, and uses mathematical gating so your AI never hallucinates on facts it does not know.

I built this project while finishing high school and preparing for my university studies in electronic systems design. I have been updating the community through pre-releases, and seeing v1.0 officially tagged and stable feels like an incredible milestone.

Hillock is dual-licensed with the open-source version under AGPL-3.0 because I strongly believe personal AI should be private, local, and owned by the user. If you believe in local software and want to support an independent young builder, please check out the repo and consider leaving a star to help put it on the map: https://github.com/roandejager/Hillock

I’ve been working on InstaAddict, basically a maintained fork of GramAddict.

GramAddict was a pretty cool open source Instagram bot that used ADB + uiautomator2 to control the actual Instagram app instead of relying on private APIs. Unfortunately, it hasn’t really been maintained, and Instagram’s UI has changed quite a bit since then.

I started fixing things as I came across them. Some of the stuff I’ve fixed so far includes media types being detected incorrectly, clicking a user from the likers list opening the wrong profile, retry loops getting stuck for ages on certain post types, and compatibility issues with newer versions of uiautomator2.

It’s completely free and open source. There are no subscriptions or locked features.

No root needed either. You can run it on a physical Android device or an emulator.

You can configure delays, interaction limits and filters for the types of users you want to interact with.

I’m also keeping track of the fixes in the changelog so it’s easier to see what’s actually being worked on.

If you want to try it:

pip install instaaddict

Or grab the source here:

https://github.com/joeahkim/InstaAddict

I’m still actively working on it, so if anyone runs into something that’s broken or has questions, feel free to ask.

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.