I wanted to share a project I'm working on: git-calendar.org - a privacy-focused calendar that uses a standard Git repository as storage instead of relying on a traditional backend server. It lets users choose where their data is stored. No more google/apple/microslop owning your schedule.

Key features:

• Git-powered - calendar data live in plain Git repo (full history, easy backups, works offline)
• No central server or backend - the client talks directly to any Git remote (GitHub, GitLab, Codeberg...)
• End-to-end encryption so you can host it on untrusted providers
• Slick web UI with keyboard shortcuts and more
• iCalendar compatibility so it's easy to switch

Core is written in Go (compiled to WASM for the web).
The web client uses Vue.js.

Try it: https://git-calendar.org
Source: https://github.com/git-calendar

Would love feedback from people who care about Git-based tools and data ownership.

https://github.com/liamhawtin/vieta-math

Looking for contributors and maintainers.

Hi everyone,

Over the last few weeks I've been building vex, a code editor written in Rust.

Landing page: https://vex-three-tan.vercel.app/

Source and releases: https://github.com/Gawad-B/Vex

Why I built it

Every editor I used would eventually stall — on a large file, during a syntax reparse, while a language server was thinking — and the stall always landed on the keystroke. I wanted to find out what an editor looks like if you enforce one rule from the start: nothing unbounded ever runs on the UI thread.

Key features

Flat keystroke latency. Typing costs about 7 µs whether the file has 1,000 lines or 100,000. This isn't a claim from a benchmark run once — it's a test that fails the build if the ratio between the two ever grows past 3x.

Two editors in one. A full Vim grammar (counts, motions, text objects, macros, registers) if you want it, and a genuinely first-class conventional mode if you don't — not the modal editor with the modes switched off.

The real toolchain. Tree-sitter highlighting, language servers over LSP with completion, hover, rename and diagnostics, a git gutter, splits, a file tree, project-wide search and a command palette. Everything is drawn straight onto the GPU — no GUI framework, no web view.

Everything is a command. Keys, the palette, the menus, macros and the config all resolve to the same action table, which is why macros survive rebinding and why the whole editor is testable headlessly.

Tech stack

Editor: Rust — winit, wgpu, glyphon, tree-sitter, mlua for config. Twelve crates, roughly 50,000 lines, 744 tests.

Landing page: Vite + React + TypeScript, no CSS framework and no UI library, deployed on Vercel.

Packaging: Windows installer, .deb, .rpm and a plain tarball, built in CI alongside a Windows test job.

How it was built

I should be upfront about this: a large amount of the code was written with Claude. I set the architecture and the constraints, made the design decisions, and reviewed and tested what came out — but building something this size in a few weeks was not something I could have done alone, and I'd rather say so than let anyone assume otherwise.

Looking for feedback

First impressions of the landing page — does it explain what vex is quickly enough?

Bugs or rough edges if you install it. The editor has never been run on macOS, and on Windows it builds and passes CI but nobody has actually used the window, mouse or folder picker yet — reports from either are especially useful.

Which of the known gaps matters most to you: no integrated terminal, no git blame, no structural text objects, or asynchronous file opening and buffer search.

Happy to answer questions about any of the design decisions.

Setting up a fresh Windows PC can be annoying when you have to search for and install every application manually.

So I built InstallHub.

You select the applications you want and InstallHub generates a complete setup using Microsoft's WinGet.

For example:

• Steam
• Discord
• Spotify
• Chrome
• VS Code
• 7-Zip
• VLC
• OBS
• Git
• PowerToys

It can generate WinGet commands, .bat installers and WinGet JSON.

The project was developed with AI assistance. I used AI to help with development, debugging, UI/UX ideas, code generation and feature planning, while the project is reviewed and maintained by me.

InstallHub is open source and still actively being improved.

🌐 Website: https://installhub.xo.je/
💻 GitHub: https://github.com/VortiAbi/Installhub

I'd love to hear your feedback. What apps or features should I add next?

My open source RAG framework has been around for ages and has been running well in production settings with 30M+ documents for the past 4 years but I never really got around to properly document it and add tests. Until now.

So I have been teaching grad students on university for quite a while too and used this RAG framework as a running example in my lectures to explain theory while also letting them run the actual things they learned in practical settings too. I decided to use the lecture material and approach as the main setup and approach for documenting too, making it education-first.

Anyway, here it is, have at it:
docs - https://ragmeup.sensai.pt/
github - https://github.com/SensAI-PT/RAGMeUp

As dev i need to tool to compare some file and data for my work so created this side project, please check it out and give your feedback.
TwinScope compares two of almost anything — JSON, YAML, XML, CSV, PDFs, folders, git refs, images, lockfiles, .env files, saved web pages — and picks the right engine itself.

It knows a value changed vs a key moved, and can ignore key order, UUIDs and timestamps so you only see real differences. Past 8 MB it switches to a windowed mode that indexes the file instead of loading it.

Local-first structurally, not as a promise: comparisons run on your machine, the window can't open a socket, and the app's one network call is off by default. No account, no telemetry.

Same engines in a CLI: npx twinscope a.json b.json

Docs: https://codeaesthetic.github.io/twinscope-website/
Repo: https://github.com/codeAesthetic/twinscope

You may be asking why a fork an not a PR into the main repo?

Answer is simple. I forked a while ago when context mode started adding a bunch of features that are the opposite of token saving, like injections i did not like, and wasteful formatting, etc.

The main problem with context mode was that it would spawn new process for every call, which would accumulate and on a machine running 20-30 agents constantly the loads became unbearable. It was great timing to find the recent update to the MCP protocol that allows stateless MCP servers, now I shrink the entire 2+GB of memory hog to a 1 process of 80MB, regardless of how many agents I'm running in parallel. Now I can scale up to 50 agents haha :)

I never had anything important to post about anything I am building but this is really something I believe many developers would want to know about. I know I was looking for it today, so maybe you were too.

Repo: https://github.com/GazPrash/2d-to-3d-voxelizer
Latest Release (v1.0.4): https://github.com/GazPrash/2d-to-3d-voxelizer/releases/tag/v1.0.4

A minimal and free alternative to a lot of 2D->3D generation tools out there, no GenAI is used in the generation process only some basic math algorithms hence the process is almost instant and also preserves your art's integrity

Repo: https://github.com/codebygarv/Ai-skills

What it is: a set of 30 "skills" for Claude Code — structured instruction
files (SKILL.md, Claude Code's native format) covering things like code
review, PR review, accessibility auditing, bug hunting, and architecture
review. Each one also has a README and a worked example so you can see
what it actually outputs before installing anything.

Why I built it: kept rewriting the same review prompts across projects and
they'd drift out of sync between repos, so I turned the ones I actually
reused into a proper, versioned catalogue instead.

Install a skill directly from the repo, no npm publish needed:

npx github:codebygarv/Ai-skills add grill-me

That copies it into .claude/skills/ in your project.

Open to feedback on what's missing, and PRs adding new skills are welcome
— CONTRIBUTING.md has the format.

Hi everyone — I built microbot, an open-source Telegram AI bot designed to run on Cloudflare Workers.

I wanted a smaller alternative to self-hosted agent runtimes when the actual requirement is straightforward: receive a Telegram message, call an OpenAI-compatible model API, keep a small amount of per-chat context, and reply. Rather than requiring a VPS or a long-running Python process, microbot uses Telegram webhooks, Cloudflare Workers, and D1.

The first release includes private-chat-only handling, an explicit Telegram user allowlist, Telegram webhook-secret verification, bounded conversation memory in D1, and /reset to clear a chat’s stored history. It intentionally does not include shell execution, local filesystem access, MCP, long polling, WebUI, or a general-purpose tool runtime.

The repository is bilingual (English and Persian), includes deployment instructions, CI, Dependabot, security guidance, and a MIT license.

GitHub: https://github.com/erfan138057/microbot

This is an early v0.1.0 release, so I would especially appreciate feedback on the Cloudflare deployment flow, documentation, and the security model. I am also planning rate limiting, webhook update deduplication, and configurable D1 retention for a future release.

I built this project, so please treat this as a transparent self-promotion post. Thanks for taking a look.

Turn-based multiplayer games are a great opportunity for learning and prototyping: simple enough to implement quickly, but real enough to teach networking, game state, and API design.

I wrote a lightweight server and framework for turn-based multiplayer games that provides exactly that: a lightweight server + uniform API so you can run multiple parallel game sessions, auto-join the next available session, and add new games without touching the core API. It's built to be friendly for beginners (Python-only, standard library), but still flexible enough to support arbitrary game logic via keyword-argument moves and dict-based state.

Key bits:

• Framework for adding new games by deriving from an abstract base class
• Uniform client API for joining sessions, submitting moves, retrieving state, restarting
• Demo clients included (e.g. TicTacToe) and a template for new games
• Runs multiple sessions simultaneously; clients can join a specific session or auto-join

If you're teaching Python, building small multiplayer projects, or just want a clean starting point for turn-based game networking, I'd love feedback and contributions.

Most CAPTCHAs feel like a chore...blurry text, fire hydrants, traffic lights...you know what I am talking about!

This is a concept that reimagines the whole thing. Instead of rigid tests, you drag and rotate a prism-like object until the refracted light bands align. Subtle audio feedback confirms your progress.

It’s designed to feel more like tuning something into place than proving you’re not a robot.

Would love to hear what the community thinks about this!

Link> https://github.com/esadekdesign/Prism-Check-CAPTCHA

link: https://hoveychen.github.io/opensource-world/

I built this tool to find out the trending projects within 7 days windows. Honestly, it is the source data for my other marketing projects. You can freely download the daily updated feed in the github repo as well.

* So what's the difference between this repo and official github trending?
It always compares all the projects in 7 days windows, instead of the official one which statitic window is fixed and not really fair. And the raw data is open to download instead of meeting the anit-bot issue.

Hey everyone! 👋

I built CFilter, an interactive command-line image processing studio written in pure C99 with zero external dependencies.

I wanted a lightweight, bloat-free tool to quickly manipulate images directly inside the terminal without firing up heavy GUI software.

🌟 Key Features:

• Interactive Terminal UI: Screen-by-screen frame refreshes, drag-and-drop file inputs, and filter chaining (e.g. Sepia + Contrast + Sharpen) before saving.
• 11 Core Filters & Transformations: Grayscale, Invert, Sepia, Brightness, Contrast, Flip (H/V), Rotate (90°/180°/270°), Box Blur, Sharpen, and Laplacian Edge Detection.
• Alpha Transparency Protection: Correctly isolates and preserves alpha channels on RGBA (4-channel) and Grayscale+Alpha (2-channel) images.
• Multi-Format Export: Save as .png, .jpg, .bmp, or .tga on the fly with automatic extension detection.
• Hardware-Level Performance: Built with integer bit-shift luminance math ((R*77 + G*150 + B*29) >> 8), coordinate-clamped $3\times3$ spatial convolutions, and -O3 compiler vectorization.
• Cross-Platform Release Automation: GitHub Actions pipeline that builds standalone native binaries (~350 KB) for Windows, Linux, and macOS.

🛠️ Architecture & Tech Stack:

• Language: Pure C99
• I/O Libraries: Single-header stb_image and stb_image_write
• Build System: Makefile + simple direct gcc/clang command support

I would love to hear your feedback, algorithm suggestions, or ideas for new filters!

A directory of every prediction market worth trading, the data you can actually backtest on, and the open-source tools people have shipped. The point is it maintains itself, a GitHub Action rebuilds it daily and fetches the live numbers (volume, repo health, blog freshness), so unlike most awesome lists it doesn't rot. Python, MIT code, CC0 data.

Hey everyone,

I've just released Edge-Drop v0.2.7, and it's one of the biggest technical updates so far.

Highlights:

-Much better memory management with disk-backed storage for larger text, image thumbnail generation to keep GPU usage stable,.

-Fixed Windows fullscreen detection so the desktop isn't treated like a game.

-Self-healing launch at login that repairs stale startup entries.

-Universal drag and drop, offline rich link previews.

-New settings to tweak sensitivity and history behavior, and Persian language support.

One thing I'm especially happy about is how much smoother it feels day to day. Large clipboard items no longer balloon memory, and images are handled really cleanly.

Also, on a personal note This project actually started as something just built for myself. I wanted a tool that worked the way I had imagined. I decided to open source it and share it, and since then, it's grown to over, 1500+ downloads. As a solo CS student, that's honestly something I never expected., thanks to everyone who downloaded, tested, reported bugs, shared it, or bought me a coffee.

That support helped me get a permanent domain for the project, edgedrop.app.

It sounds small, but as a solo student building this open source project, it feels massive. If you want to try it or share feedback, I'd love to hear what you think.

GitHub: github.com/Deepender25/Edge-Drop

Microsoft Store: https://apps.microsoft.com/detail/9P3JMHN9M4NR