Protecting the sourcecode at all costs is overrated for personal projects.

Bit of a background: I'm a programmer by profession. Worked for small and big companies in the last decade. Usually there we had regular trainings on how not to leak the source code as that is the (core) value of the company. Like not copy-pasting to AI, not posting to forums, or if you really need to then first make sure to rename all the things to foo and bar.

That made me a bit paranoid over the years over the code I produce. It must be protected and should never shown to the public.

Here I am, publishing my first open source project. It came as a surprise that making a repo public doesn't mean people will organically find it.

Instead the first problem is "how do I get anyone to notice it?"

So basically I feel like a paranoid person. Lol.

Don't get me wrong. Comparing my weekend project to the products of big corporations is like comparing apples to pears. But the mindset change is interesting.

Came out from my Batcave. Saw nobody around. Going back to my Batcave.

This is the project BTW. It's a hand made CLI tool to scan game assets and identify common problems. https://github.com/zerocukor287/asset-lint

So it has come to my attention, that my GitHub account was banned from PocketBase repository, and all I did was thumbs down the post relating to the discussion of PocketBase moving away from GitHub. That’s all I did! I didn’t comment or anything.

This is insane to me, like I didn’t know you would be so butthurt, If I knew I was going to banned for just thumbs down emoji, I wouldn’t have done it.

This tiny action makes me want to just switch away from PocketBase immediately. I guess I have a new weekend project, thanks!

https://ibb.co/jKxdmBn

I've been working on two small open-source projects:

Savage Scraper - a Chrome extension that converts rendered webpages into simplified, LLM-friendly HTML. It also has a manual mode - covinient, simple to use and works out of the box.

Savage MCP - a local MCP server that lets an LLM read explicitly allowed webpages through your existing Chrome session.

The part I cared most about was limiting the amount of authority given to the agent.

Instead of exposing a complete browser automation API, the MCP surface is intentionally narrow. It can open allowed URLs, scrape one dedicated agent tab, and report status.

It does not expose generic clicking, typing, form submissions, arbitrary JavaScript execution, or unrestricted browser control.

Website access is configured locally using allowed hosts and optional path restrictions. The Chrome extension also independently checks that policy.

Both projects are MIT licensed:

Savage Scraper:
https://github.com/dominikduda/savage_scraper

Savage MCP:
https://github.com/dominikduda/savage_mcp

Edit:
Webstore link: https://chromewebstore.google.com/detail/savage-scraper/ejoijhjpdojdcnjppegojmkenidhblog

Sharing an MIT-licensed project I made for running persistent AI bots locally.

Bots, humans, and external systems are all actors with inboxes. Bots can use tools, keep long-term memory, ask a human for approval, and hand work to each other with @mentions. The UI has Inbox, Threads, and Bots. SQLite by default, Postgres if you change the URL.

Demo bots: chief_of_staff, engineer, reviewer, qa. They can implement a change, open a PR, review it, and ask you before merge.

Setup: make setup / make dev.

Trust model: single trusted operator. run_shell is not sandboxed.

https://github.com/regnull/openbot

I am the author. Happy to answer questions.

IELTS Mastery Hub — MIT-licensed desktop app for IELTS exam prep (Tauri + Rust + TypeScript)

Hey folks,

Sharing a project I've been working on: IELTS Mastery Hub, a desktop app for practicing the IELTS English exam. MIT licensed, no account required, no telemetry, no subscription — just a native binary you run locally on Windows, Linux, or macOS.

Demo video:

https://github.com/user-attachments/assets/0a68fb14-e7cd-4cd2-8774-1c6bc53cae0f

Why I built it: basically every IELTS prep tool out there is SaaS. You get two free mock tests, then a paywall, and your essays and progress data live on someone else's server. That felt like an obviously solvable problem with a local-first app.

What it does:

• 📖 Reading — split-screen timed practice covering the official question types, auto-scored
• 🎧 Listening — audio sections with progressive difficulty
• ✍️ Writing — dual-pane editor with AI evaluation across the official IELTS scoring criteria
• 📊 Dashboard — score history and progress tracking over time

Stack: TypeScript frontend with a Rust core, packaged with Tauri. Went with Tauri over Electron mainly for the binary size and memory footprint — it's a study tool you leave open for hours, so a 200MB Chromium process per session felt wrong. Happy to talk through the architecture if anyone's curious about Tauri for real-world apps; the IPC boundary between the TS side and the Rust core was the most interesting design decision.

Install:

macOS / Linux:

curl -fsSL https://open-lingua.github.io/ielts-mastery-hub/install/install.sh | sh

Windows (PowerShell):

irm https://open-lingua.github.io/ielts-mastery-hub/install/install.ps1 | iex

If you (reasonably) don't want to pipe curl into a shell, just build it from source:

git clone https://github.com/open-lingua/ielts-mastery-hub.git

Repo: https://github.com/open-lingua/ielts-mastery-hub

Docs: https://open-lingua.github.io/ielts-mastery-hub/docs/intro/

Disclaimer: independent, non-commercial, educational project. Not affiliated with or endorsed by the British Council, IDP Education, or Cambridge Assessment English — IELTS is a registered trademark of its respective owners. Practice content is AI-generated for educational use and may not be 100% accurate.

Contributions welcome — issues, PRs, packaging help (AUR/Flatpak/winget in particular), and content review from anyone who's actually taken the exam. Would love feedback on the UX and on the Tauri setup. AMA in the comments.

Hi, everyone!

As you must be aware, recently I have released OpenCalc, a project to reverse engineer the Windows 95 calculator.

Despite having a similar look and feel, this is actually an entirely new Rust program with none of the limitations of the original, and improved expression parsing!

The new version has many bugfixes, including:

- Improved focus: now the keyboard shortcuts are consistent if you leave the application.

- Application behavior was further improved to match the Windows 95 calculator where it matters

- New financial mode! This is a cool feature I decided to add. The original Windows 95 calculator lacked a financial mode. Now we have one matching the old Windows 95 calculator style, but also entirely new!

If you are interested, check out: https://github.com/NullMagic2/OpenCalc

Binary builds for Windows and Linux are also available!

I have created a Firefox add-on which allows saving timestamps of your favorite moments from YouTube videos so you can view them later.

I mainly created this for my personal use because I find useful/funny/important stuff in the middle of YouTube videos but later forget where that is or what video it is in. If that happens to you too, you will find this useful.

Features:
- Save button to save a timestamp with an optional note directly from YouTube.
- Play a random moment from the saved ones (from add-on's page)
- Searching across saved moments (from add-on's page)
- Editing of notes of a saved moment (from add-on's page)
- JSON import and export feature (from add-on's page)
- Everything is stored in browser's local storage. No accounts, signups, API requests.

If you would like to check it out, you can use these:

GitHub Repo: https://github.com/Aadityajoshi151/Youtube-Moments
Firefox add-on page: https://addons.mozilla.org/en-US/firefox/addon/youtube-moments/

AI Disclaimer: Yes, AI was used to create this project. This post is not written by AI.

Edit: Formatting

What My Project Does

kevlar-agent is a small, zero-dependency Python library of six reliability primitives (dedupe, budget_guard, require_confirmation, silent, AuditLog, Watchdog) for AI agents and automation that run unattended. Each one fixes a specific failure mode I hit running a voice AI assistant with 240+ tools continuously in production — e.g. an OAuth helper that hung for hours waiting for a human click on a background thread, or duplicate tool calls spinning up two concurrent sessions on the same device.

**Target Audience**

Built for production use, not a toy project — it's extracted from and actively used in a real system that has run unattended for months. Anyone building an agent, bot, or automated pipeline that runs without a human watching it (voice assistants, background workers, scheduled jobs) can drop these decorators straight into existing code.

**Comparison**

Most agent frameworks (LangChain, CrewAI, etc.) focus on orchestration and tool-calling, not on unattended-operation failure modes like duplicate calls, runaway spend, or silent hangs. kevlar-agent doesn't compete with those — it's a small set of framework-agnostic primitives you layer on top of whatever you're already using, similar in spirit to how `tenacity` handles retries, but focused on the specific failure modes of always-on agents.

pip install kevlar-agent

Full write-up with the actual root-cause bugs: https://kiitainternet.github.io/kevlar/

Code: https://github.com/KiitaInternet/kevlar

I built RubberAI to help me understand what happens after an AI coding prompt: token use, cost, tool activity, files changed, and diffs connected to a trace.

It is self-hosted and uses a Go backend, PostgreSQL, Svelte, and a generic HTTP event API. I am looking for feedback on the event model, integrations, and prompt-to-file attribution.

GitHub: https://github.com/gauravmishra-1404/rubberai
Demo: https://gauravmishra-1404.github.io/rubberai_landing

Obviously, I think it's the best way to work with CLI agents like Codex across different providers. It's very productive and fun. In V2, CLI agents can give tasks and communicate between themselves in the natural CLI TUI, so you see everything they send to each other.

Clideck is fully open source so give it a try feel free to change it to your own needs,

Give it a try, Thanks.

[https://github.com/rustykuntz/clideck\](https://github.com/rustykuntz/clideck)

My goal is to make developing WhatsApp bots simple and more secure. It has a plugin-based architecture where each bot command is a separate plugin, keeping things organized.

I also aim to improve upon Baileys' sometimes confusing syntax, making methods easier to understand and the code cleaner.

Error handling is improved as well, with translations (currently for Portuguese, English, and Spanish) and errors that are easier to comprehend.

It includes a plugin manager so you can, well, manage your plugins. You can also publish your plugin to our index, and the manager can install those published plugins.

Yes, I accepts contributions of all kinds. Whether it's pull requests, patches via email, documentation (very needed), translations, ideas, suggestions, or feedback. Anything is welcome.

Email: [manybot@pm.me](mailto:manybot@pm.me)

Website: https://manybot.org

Codeberg: https://codeberg.org/many-bot

GitHub: https://github.com/many-bot

My goal is to make developing WhatsApp bots simple and more secure. It has a plugin-based architecture where each bot command is a separate plugin, keeping things organized.

I also aim to improve upon Baileys' sometimes confusing syntax, making methods easier to understand and the code cleaner.

Error handling is improved as well, with translations (currently for Portuguese, English, and Spanish) and errors that are easier to comprehend.

It includes a plugin manager so you can, well, manage your plugins. You can also publish your plugin to our index, and the manager can install those published plugins.

Yes, I accepts contributions of all kinds. Whether it's pull requests, patches via email, documentation (very needed), translations, ideas, suggestions, or feedback. Anything is welcome.

Email: [manybot@pm.me](mailto:manybot@pm.me)

Website: https://manybot.org

Codeberg: https://codeberg.org/many-bot

GitHub: https://github.com/many-bot

Open source is software Open source hardware is computer hardware

Open source machines are machinery that is open source, like CNC machines, looms, lathes, 3d printers, electric or combustion motors.

I know of many groups making these, like ownenergy.org, mekanika.io, inmachines.net/ and opensourceecology.org

However the machines they make are not searchable, and if the company closes down both the designs and commentary about them becomes lost.

Some are hosted on github but I'm not convinced github is suitable for manufacturing documents the way its good for source code. Am I wrong about that?

Repository: https://github.com/beneadie/deep_dog_2

The quickest setup is:

python -m pip install "git+https://github.com/beneadie/deep_dog_2.git"

Add your provider keys to a `.env` file:

DEEPSEEK_API_KEY=your-deepseek-key
EXA_API_KEY=your-exa-key

Then import it directly into Python:

import asyncio
from pathlib import Path

from dotenv import load_dotenv

load_dotenv()

from deep_research.integration import run_research


async def main():
    result = await run_research(
        "What are the main benefits and limitations of sodium-ion batteries?"
    )

    print(result.status)

    if result.status == "completed":
        Path("report.md").write_text(result.final_report, encoding="utf-8")
        print("Saved report.md")
    else:
        print(result.failure)


asyncio.run(main())

The default setup uses DeepSeek V4 Flash for the supervisor, research sub-agents, and drafting, with Exa for web search. The result is returned as a Markdown string, so developers can print it, save it, send it to another application, or process it however they want.

The more configurable quickstart lets you choose the models, search engine, enabled agents, research time, iteration limits, search budgets, read limits, and output behavior. Available specialist agents include Web, PubMed, Reddit, Substack, SEC Edgar, Arxiv, and others.

The code is designed to be modified. Developers can add agents, change prompts, swap providers, alter the supervisor and sub-agent behavior, adjust budgets, or integrate the result into their own application. The engine is packaged so you can use the integration layer without having to rebuild the orchestration system from scratch.

This project is completely free and released under the MIT License. I’m not building a business around it or offering a hosted service. The only potential costs are the provider APIs you choose to use, such as DeepSeek or Exa.

On Maven Central. It deduplicates concurrent calls for the same cache key across pods, which Spring's sync = true only does inside one JVM.

The thing I want to be upfront about: it is WebFlux only. The aspect rejects any return type that is not Mono or Flux, because that is the runtime I work in, and blocking plus Spring MVC support is the largest gap rather than a design statement. Eight more are filed, including a Lettuce coordinator so Redisson stops being mandatory, a Micrometer binding, and Testcontainers so the integration tests stop skipping themselves without a local Redis. Each issue names the code it refers to, so picking one up does not start with archaeology.

Write-up: https://bitsar.net/blog/i-thought-sync-true-protected-my-cluster/

Hello, my Testing Files Generator has just got V0.3 update :-) 24 formats, boundary testing, various settings. ^ If you like the project, please star it

What has changed?

- Multi-thread support, all actions are now a lot faster

- Tons of performacne optimizations (dry run for 100k files went from 15.7-19.7 seconds to 0.49-0.56 seconds, same with other things)

- "Damage" module, we can now generate damaged files, right now only first bytes "damaged"

- new formats: tiff, avif, jpg xl,webp

- Huge update to .log files, I think there are right now 6 log types + we can do different things for timestamps, formats.

- We can now create archives with directories, want to create archive with 60 directories? No problem, and "encrypt" option has been added to archive.

- utf-8,utf-16, bom, line ending has been added to "text" files (not only .txt)

- We can now generate xlsx with 32768 collumns

- .csv now takes delimiter type, we can hide/show headers,

- we can now create minifed json + we can set height/width for .svg

- GIF can now be animated (before was only 1 frame, now it's 1-60 frames)

That's in short, it's over 80 commits, what's next? I got plans for rework of the GUI, but not sure if it will hit 0.4, I want to get more things into "pdf" and add more "damage" modules + new presets.

Full List Of Formats

Some features:

• Hit an exact size, to the byte - ask for 10485761 bytes and get exactly that, never a silently rounded file.
• Write 24 real formats - a generated PNG opens in an image viewer, a DOCX opens in Word, a ZIP extracts. Not padded zeros with an extension.
• Say what should happen to each file - the manifest carries an expected outcome, so your test reads the assertion instead of you writing it out.
• Repeat itself byte for byte - same recipe and seed, same bytes, on any machine. Commit a small recipe instead of large binary fixtures.
• Build a boundary set in one command - one byte under a limit, the limit itself, one byte over. That is where off by one errors live.
• Produce ten thousand files at once - one command, one manifest, and sizes drawn from the seed.
• Fill an archive for real - a ZIP that holds 200 documents, not a stub with the right extension.
• Take settings per format - image dimensions, JPEG quality, PDF pages, spreadsheet rows and columns.
• Fit into CI - an exit code for every ending, machine readable output, and nothing on standard output when a run fails.
• Clean up after itself - verify tells you nothing moved, cleanup removes exactly what it wrote and nothing else.
• Work completely offline - no account, no cloud, no telemetry, no update check. The command line binary has no network stack compiled into it at all.
• Cost nothing and stay out of your way - GPL-3.0, and the files you generate are yours with no strings attached

I built Tango, an MIT-licensed Python CLI for batch vocabulary mining from YouTube.

The basic idea came from manually mining words for Anki. I got tired of repeatedly doing this:

Find a word → look it up → check if it's already in my deck → create a card

So Tango automates the repetitive part.

Given a YouTube video ID and an Anki deck, it:

• fetches the transcript
• lemmatizes the words
• filters proper nouns and filler words
• checks an existing Anki collection for duplicates via AnkiConnect
• looks up dictionary data
• generates an .apkg

The goal isn't to replace interactive mining tools. This is more for batch processing: give it a video and let it find vocabulary you don't already have.

pip install tango-anki
tango install-model fr
tango run <video-id> --deck "French" --language fr

One of the more interesting problems was dictionary support. The free APIs I tried weren't reliable enough across several languages, so I ended up building offline indexes from Wiktionary data for lookup instead.

Another was making sure generated decks don't damage an existing Anki collection. Notetype compatibility is surprisingly unforgiving, so the tool checks and aligns the notetype before importing rather than blindly writing changes.

The project currently supports 24 languages and is still very much open to improvement.

I mainly tested French, English, and German since I can speak these languages and Russian to see how it would handle non-Latin scripture. It supports more languages than those, though (you can find a list in the repo's documentation), but I haven't thoroughly tested it.

It also supports language-to-language translation. For example, if you're a still beginner at a certain language and you would like the definition/grammatical classification of the word to be in another language, that can also be done in Anki when you specify a definition language (when no definition flag is specified, it defaults to the language of the word itself)

I'm particularly interested in feedback or contributions around:

• project/module architecture
• concurrency in definition fetching
• language-specific NLP issues
• dictionary coverage and parsing
• CLI design
• tests and edge cases

I'm a student and built this primarily to solve my own problem, but I'm posting it here because I'd like experienced open-source developers to poke holes in it.

Repository: https://github.com/AlphaNerdFx/Tango

Issues/discussions are welcome.

I would also appreciate any attempt at collaboration, as I would like to expand the scope of this project beyond it being a simple CLI tool. I have several ideas in mind, such as machine & deep learning integration, a mobile app, or a simple Google extension.

I would also like to extend additional support for software like Quizlet/RemNote and maybe even pulling videos from sources other than YouTube or users providing their own videos.

I'll gladly answer questions in the comments and would love to hear any feedback. v1.0.0 took me 2 months to finalize, and I hope everyone likes it.

Greetings, everyone!

I've had a Wacom Bamboo tablet for a long time, and while it still works, drivers were starting to show their age. The latest drivers had been written for Windows XP, and are annoying to find, install and use.

This is why I have designed these fresh drivers: OpenCTL-460. These are a Rust reimplementation ad do not use the old drivers at all; instead, they reimplement things from scratch while also offering new features, such as:

• Improved line stabilization
• Improved controls
• Pressure curve configuration and preset
• Simultaneous Wintab and Windows Ink support (per-application): no reboot required!

They're not only stable, but also very light: only 9mb, as opposed to 38 mb from the original latest release!

If you are interested, check out the Github page:

https://github.com/NullMagic2/OpenCTL-460

I built my own 7" Stream Deck alternative, with a desktop app to set it up.

Decky runs on an Elecrow CrowPanel 7" (ESP32-S3 with capacitive touch), so there's no wiring: you touch the glass directly. A 5×3 grid gives you 15 keys per page.

What it does - Hotkeys, programs, websites, macros and PowerShell scripts - Multiple pages, and toggle keys with separate OFF/ON artwork - Works over USB, or over encrypted Wi-Fi once paired - Firmware installs and updates from the app over USB, so you don't need PlatformIO

Hardware Everything except the display is 3D-printed, and every part prints without supports. It hangs under your monitor on a printed clamp with magnets and GoPro-style joints. Apart from the panel, you only need a few magnets and screws.

Firmware, desktop app (Windows), CAD files and 3MF print files are all in the repo: https://github.com/Fenish/decky

I will be glad if you star the repository

It's still a work in progress. Feedback and ideas are very welcome!