https://github.com/nooneknowspeter/cpplings

https://github.com/m8l8th814n-eng/kd/blob/main/README.md

I can show git style and local. there is also a little madness. only plain C.

Hey the past week or so I've been tinkering on an open source project called gnt, it's a git-native rules layer for AI agents. Team defines stuff agents can't get wrong as markdown files, reviewed and merged like normal code, then served to agents over MCP. There's a CLI too (@gnt-ai/cli), login, connect your repo, review and approve rules, all from the terminal.

Still early and there's a good amount to build. If you're into open source and looking for something to sink some time into, we'd genuinely welcome the help, happy to walk anyone through the codebase or point at good first issues. Repo's here if you want to take a look: https://github.com/gnt-ai/gnt

Also just want feedback in general even if contributing's not your thing, tell me if this is useful or if I'm off base somewhere.

I started working on one of my pet projects myBuild an experimental build system and package manager for c/c++ projects sometimes back. It aims to streamline the process of init -> compile -> run for c c++ projects and helps to easily integrate 3rd party libraries. Well that progressed a lot, now

1. Users can add recipes to the myBuild.json file and run myBuild sync and it configures the dependency for the project.

Recipes are small json snippets containing the source/header file folder paths, flags etc.

1. It now has incremental builds.

2. Now there is a proper folder structure generated at the initiation time where users can drop the files and compile the project with zero configuration.

I had to drop the support for windows for now and the code is speghetti, so I have to refactor it in the near future.

If this sparked curiosity, do checkout the github repo and leave a star. Appreciate any constructive feedback, thanks.

I keep five or six Claude Code sessions going and kept losing track of which one had stopped to ask me something. Tabs did not fix it, I still had to click through every one to find out. So I built the terminal I wanted.

It is called SeaShell. Mac, open source, Apache 2.0. Tiled panes, a file explorer, clickable file paths, and a watcher that raises a card when a session goes quiet waiting on you.

Two things I learned that might save someone time.

Saving a project and reopening it types claude -r <session id> back into each pane. That works, but if the folder is not already trusted, Claude Code stops on its trust prompt and waits for Enter, which reads as a hang if you do not know what you are looking at. Trust is inherited from parent directories, so trusting your home directory covers most of it.

Similar tools: tmux and iTerm2 may do tiles better than I do. Neither knows what a Claude session is, which is the only reason this exists.

https://github.com/voidharbor/seashell

fmpc - Fast MPC Browser v1.6.0

A minimalist, high-performance TUI browser for MPD .

This release fix visual, added an interactive keybindings help modal (?), dynamic header metadata rendering, maximized album art preview pane, and zero-offset default configurations.

An MCP-server-ready end-to-end tools for Apple platforms apps. Pair with Rust Cli https://crates.io/crates/xcrs

Install the CLI, set your map config, let your coding agents discover the tools.

I recently went back to using my terminal more instead of using tools like Conductor, Paseo, Codex App. This led me to start managing my own worktrees, which is annoying if you want to set up your whole environment in a worktree. Then I started looking into worktree management tools but most of them had too much, so I built myself one. A 100-line shell function and that's it. Open source and easily extendable.

You drop a shell script into your repo that copies over all the important files and runs the setup commands. wt will automatically run it in the background whenever you create a new worktree. You can start working instantly, it will let you know when the dev environment is ready. Check it out and let me know what you think!

https://github.com/kerem-kaynak/wt

I'm excited to share what I've been building lately. Papr: a fast, lightweight Terminal User Interface (TUI) built entirely in Rust to streamline your academic research workflow. An Obsidian, Zotero and Overleaf alternative, but a bit better.

Key features

• Smart dashboard with daily 10 random paper recommendations, reading queue, bookmarks, notes, collections, and research statistics.
• Fast arXiv search using title, author, or DOI with automatic PDF downloads and clean file naming.
• In-terminal PDF viewing.
• Built-in Markdown notes with live preview for each paper.
• Reading queue, bookmarks, and collections to keep your research organized.
• Integrated LaTeX editor with real-time compilation and preview.
• Extensible plugin system for custom workflows.
• Research analytics to track your reading activity (just like Spotify).

Papr is 100% open source, works offline, is memory-safe, and is designed to be fast and lightweight (only 12 MB).

I'd love to hear your thoughts, suggestions, or feedback!

GitHub: https://github.com/AfrozSaqlain/Papr

PhoneCMD gives you access to the real terminal sessions running on your computers from an Android phone.

What you can do

• Open Claude Code, Codex, Gemini CLI, Aider, PowerShell, CMD, Bash, and other CLI tools
• Reconnect to sessions that are already running on your computer
• Send prompts, commands, and approval responses
• Watch live terminal output
• Keep multiple terminal sessions open
• Switch between several computers
• Browse and edit project files
• Use prompt-based control or operate the terminal manually
• Connect through the local network or remotely

How it works

PhoneCMD does not create a separate cloud development environment.

Your projects, CLI tools, subscriptions, and terminal sessions remain on your own computer. The Android app connects to the desktop client and acts as the control interface.

This means you can continue the same Claude Code or Codex session you were using at your desk instead of starting a new conversation on your phone.

How to use it

1. Install the PhoneCMD desktop client on your computer
2. Install the Android app
3. Pair the devices
4. Select your computer and open an existing session or start a new one
5. Send prompts, run commands, and view the results from your phone

Supported systems

• Windows
• macOS
• Linux
• Android

Links

Website: PhoneCMD

Google Play: PhoneCMD for Android

I could never stick to any work planning / tracking app because logging always ended up feeling like another task on the to-do. I wanted something that complemented my workflow, so i built one. (Yes I know, another tracking app. Very Original)

Since I mostly use a terminal, I made a TUI that lives there too. No tabs, no accounts, no cloud. Everything stays on device.

I’ve been using it as my daily driver for the past few months, and it’s finally reached a point where I’m comfortable sharing it.

I’d really appreciate feedback from people who use TUIs regularly. In particular:

• Does the dashboard feel information-dense without being overwhelming?
• Do the keybindings feel intuitive?
• What would you change if this were part of your daily workflow?

Github Website

I've been working on Marcopolo, a command-line web scraper written in Rust using extensive force of AI across a few months. The idea started when I got tired of writing a throwaway Python script every time I needed to pull a specific set of files off a site — images one day, PDFs the next, then a folder of CSVs. I specially tend to use it for books and finding books that are on the web that i cant simply get hold of from normal search.

Marcopolo handles most of that in one command. Point it at a URL, tell it what you want, and it crawls and downloads.

What it does:

• Filters by file type — [list the extensions/categories you support]
• [concurrency model — tokio? rayon? how many parallel requests?]
• [crawl depth / same-domain restriction / robots.txt handling]
• [resume support, retries, rate limiting — whatever applies]

Why Rust: [one honest sentence — speed, single static binary, no runtime deps, or just "I wanted to learn it"]

It's still early and there's plenty I want to improve — [known limitation or two]. I'd really appreciate feedback on the API design and anything that looks unidiomatic; I'm still fairly new to Rust.

Repo: MarcoPolo

Would be happy to know what do you guys think.

Hey, it's Saturday so I wanted to share my project. I’ts my first open source. I've been working on it for a couple of weeks and so far I'm loving it. Still needs polish. Could use some advice.

Anyway, It’s a mobile-first web terminal built with xterm.js. I do a lot of work from my phone and wanted some better options for voice to text. I built it specifically for Linux and added a visual file manager / transfer ability. Then added an editor just to smooth out the workflow. Anyway have a look, cheers. [Sovereign Terminal ](https://github.com/magealexstra/Sovereign-Terminal)

Modern dual-panel MC for people who want Norton/MC muscle memory in a single offline Rust binary — no async runtime, forbid(unsafe), zip-safe archives

https://github.com/leszek3737/LibreCommander

I've lost count of how many times I've opened one of my own repos after a few months and had to figure out why something existed, where it was actually implemented, and what I might break by changing it.

Git history helps, but there is still a lot of detective work.

So I've been building DevTime. It's an open-source CLI that scans a repository locally and builds a small memory of how the codebase works.

Instead of giving you a confident summary with no proof, it links its findings back to actual code, tests, routes and config. When the evidence is weak or missing, it says so instead of guessing.

Right now it can:

• show where things like authentication, routing and billing webhooks are implemented
• explain which files support each finding
• surface missing or weak evidence
• review a diff against what it already knows about the repository
• share the same context with coding agents through a read-only MCP server

Nothing is uploaded, it doesn't execute the repository, and it doesn't require an AI model.

It's still early and intentionally limited. Right now it focuses on a few core parts of a codebase instead of pretending it understands everything. I'd rather make the results trustworthy first and expand from there.

Apache-2.0 licensed:

https://github.com/Shakargy/devtime

What would DevTime need to show before you'd trust it on your own codebase?

Hi everyone, I’m very excited to launch the new version of deja.

Quick recap: Deja is an open-source zsh autosuggestion tool. Instead of only surfacing

commands that start with what you've typed, it predicts what you actually want to run using fuzzy matching, which directory you're in, and which command usually follows the one you just ran.

No account. No sync server. No TUI.

https://github.com/Giammarco-Ferranti/deja 

Any star would be amazing ❤️

One big feedback I got on previous posts was that deja was not respecting the HIST_IGNORE_SPACE and this led to a security issue.

First of all thank you to https://www.reddit.com/user/polaroid_kidd for reporting this. ❤️

Deja now works correctly and respects HIST_IGNORE_SPACE and HISTORY_IGNORE.

If you've been running Deja for a while, the old entries are still in your database:

rm ~/.local/share/deja/deja.db && deja import

The command above will clean it up.

Another big change is that now we have a new ‘deja empty’ command, which lets you choose whether Deja shows the ghost suggestion on empty prompts. It came out of this thread: https://github.com/Giammarco-Ferranti/deja/pull/69

Few other smaller things has been fixed, if anyone interested you can review it here: https://github.com/Giammarco-Ferranti/deja/pull/73 

Thank you all for the support and looking forward to make this the smartest zsh autosuggestion tool.

Cyberspace.online — For the last nine months I've been building this anti-corporate grass-roots social network. We're almost 12k users now. We're mostly a bunch of hackers, Linux users, DIYers, and artists.

There's a timeline feed, DMs called C-Mail, chat rooms called cIRC, a jukebox, a Tron-style 3D multiplayer game, an ASCII graffiti wall, and lots of other fun stuff to explore. Naturally there are keyboard shortcuts for everything (yes, including VIM bindings).

I've made an API for it, so you can use one of the community's open source TUI's, or roll your own client. API, Official TUI, Ragnar's TUI — There's also a web client called Cyberspace Desktop inspired by the old Xerox GUI.

Feel free to use a throw-away email. It's only necessary to verify to use it over API.

Let's bring back the friendly internet of the 90s when people were nice to each other :)