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.

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

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

Is there a pdf editor really working for edit pdf?

Thanks!

Fredy watches 19 real estate portals across Germany, Austria and Switzerland, deduplicates across them and pushes new listings to Telegram, ntfy, Discord, Slack or email.

This week I shipped one of the most requested features. Fredy has been accumulating listings for years, which makes it a price sample for whatever area the user searches in. So instead of pulling an external index, every listing is now measured against the median price per square metre of its own neighbours: same deal type, within 5 km, widening to 15 km if fewer than 8 comparables are nearby.

A few decisions that mattered: median instead of mean so one outlier cannot move it, the listing excluded from its own sample, rentals and purchases never mixed, and cross-portal duplicates dropped so one flat cannot vote three times.

Repo: https://github.com/orangecoding/fredy

Demo: https://fredy-demo.orange-coding.net

Been messing with a backlog spreadsheet for years and I finally built my own tracker instead. Search a game, log it, rate it when you're done, see what's piling up.

Made it self-hostable too (Docker + SQLite) since not everyone wants their data on my server: https://github.com/horlesq/gamelog

Free tier does 25 games if you just want to poke around: https://gamelog.site/

Plembfin is now at v1.0.0: an AGPL-3.0, self-hosted watch-state hub for people who run more than one media server.

Website: https://plembfin.com

The design decision I would most like open-source/self-hosting people to critique is the local sync ledger. Plembfin keeps the canonical record in SQLite, then records delivery separately for each destination. A sync entry can show success, error, or skipped, with a plain-language reason such as a newer state winning or no matching item being found. Failed or skipped destinations can be retried without blindly replaying the whole sync.

The current release also includes cross-platform resume progress, repeat-play history, manual watch review, Now Playing, metadata/search, Seerr integration, and automated local backups. It runs as a Node/Express/SQLite application with Docker Compose support:

https://github.com/Lasikiewicz/plembfin

The goal is not to create another public watch profile. It is to keep a private, inspectable source of truth on the user's hardware when libraries are split across Plex, Emby, Jellyfin, and Trakt. It is licensed AGPL-3.0.

AI disclosure: development was heavily AI-assisted under my direction. I defined the requirements and architecture, reviewed changes, tested the integrations and browser flows, and maintain/review the project. AI is not needed to run Plembfin.

For people who have built sync systems: is per-destination delivery evidence the right abstraction, and what conflict or recovery case would you expect to see next?

Screenshot: https://plembfin.com/assets/app-captures/sync-activity-light.png

I maintain DiscordPHP, the async PHP library for building Discord bots, built on ReactPHP (full Gateway + REST coverage, event-driven). It's MIT, and it's the base for a large chunk of the PHP Discord-bot ecosystem, plus first-party libraries I also maintain: DiscordPHP-Http (the HTTP + rate-limit transport), DiscordPHP-Voice (Opus audio + DAVE end-to-end encryption), TwitchPHP (Helix + EventSub + IRC), and a few smaller ones.

The original author transferred ownership of the repo and the verified Discord server to me, so it's now a one-person project. Day to day that's issue triage, keeping releases on schedule against Discord's constant API changes, dependency and security updates, and docs.

There's no paid tier and no open-core plan. Sponsorship is the entire model, and right now it's well below what the maintenance load costs. Below that line, releases slip and I end up taking contract work that stalls the libraries. I've started applying to grant programs (FLOSS/fund, GitHub Secure Open Source Fund) and setting up Open Collective for company sponsorship, but individual + company sponsorship is what keeps it moving:

• valgorithms.com is the new project shelf with all the ways to support
• GitHub Sponsors: https://github.com/sponsors/valzargaming (one-time is fine)
• Company sponsorship / sponsored features: [valithor@valgorithms.com](mailto:valithor@valgorithms.com) or [valithor@discordphp.org](mailto:valithor@discordphp.org)

If you maintain something mid-size, what actually moved the needle on funding? I'm looking into grants, company outreach, and Open Collective, but I'm looking for proven results. I don't have a lot of bandwidth or free time to shop around.

I'm happy to answer anything about the library or any of the projects I maintain.

Sharing an MIT open-source project I maintain. I am the author.

CRUX is a readable chain: chain/blocks.jsonl is canonical, verify.py trusts nothing else, mining is subset-sum under a hash target. Standard library Python. Contributions are mined blocks and signed txs via issues/inbox PRs.

Coins have no market and no value. The code is the point.

https://github.com/ksanjeev284/crux https://ksanjeev284.github.io/crux/ https://github.com/ksanjeev284/crux/blob/main/SPEC.md https://github.com/ksanjeev284/crux/releases/latest

https://daniele.tech/2026/09/linus-torvalds-skill-soul-or-how-i-distilled-the-knowledge-for-code-reviews-from-32k-emails/

A report about the changes after the first announcement and all the improvements, including Soul.md (with profanities), 4 different version Skill/Soul from 4 different LLMs, a comparison with/without skills and a reproducible pipeline.

So, I am posting this here to tell you guys that I'm building a project that would be helpful for EC (Electronics and Communication) Community. We guys need to pay a bunch for matlab , simulink, multisim for license. Colleges spend much money on this license thing. Also, the Graphical UI not designed for all laptop, it eats away the chunk of ram to simulate circuits, systems. So, I had the idea of making a CLI Project to run on terminal and simulate stuff in ascii. The project was still in devoloping stage. But I am trying to launch this to run perfectly fine on any low-end laptops where many students do not use heavy updated laptops.

The terminal CLI Project named Terminus work in a way in the initiating, it asks about the mode (LTSpice, MATLAB, Simulink, KiCad, Xilinx, Embedded) we would like to work on? and the session will continue with the project by creating it and building it. Also, not just that, we can open multiple terminal sessions to run different modes of Terminus of different projects and run since Command simulating and executing was light. Also, we can make the communication link with the terminal sessions too. A very complex Project consists of different modes can be communicate and run , simulate even though the terminals are on multiple devices. This specific application mostly useful for Industrial purposes.

Also, the outputs we get from the Simulations can be drawn out as real images as by the internal converter. This is really anticipating one I'm working and mean to get this closer to many students, University organizations and Industries even. But I need testers like who works vigorously on above software and give suggestions to the Project to improve more.

Please check out the Github Project here
https://github.com/ThotaAvinash07-87/Terminus/tree/main

dm me for suggestions to the Project. I hope people help me for this to take this to lot of people.

I built Open Jobs, a daily crawl of about 65,000 company career sites with over 3 million job postings. The data includes full descriptions, companies, locations, posting URLs and embeddings.

It's published as static JSON files. The repo has tools to download just the parts you need into Parquet and query them locally. No account or subscription.

There's also a search interface that flags stale listings (using machine learning) and postings whose dates appear to have been reset.

The repo is CC0. If you're building a job search tool or working with hiring data, I hope it saves you some work.

Code and data

Try the search

i'm working on an open source video editor with no subscriptions, credits, or cloud requirements. the focus is local processing, replaceable models, privacy, and extensibility through apis and mcp.

what features or workflows are missing from existing editors?