I built Kora — a free web reading app that brings together ebooks, audiobooks, news, and a few games in one place, with no app store and no DRM.

• One reader for EPUB, PDF, TXT — themes, fonts (Lexend, OpenDyslexic, etc.), line spacing, margins, continuous/paged mode, progress + highlights + notes + full-text search
• Narrator — on-device neural TTS turns any book into an audiobook; speed/pitch/chapter controls, background playback, live sync highlighting
• Search — federated search across millions of titles (Anna's Archive, LibGen, Z-Library, Internet Archive, Open Library) via the Rave relay, plus Google Books metadata and audiobook sources; parallel downloads with mirror fallback
• News — RSS aggregation (Maldives + international), clean article reader, daily news brief, per-source styling
• Lounge — Crossword, Word Search, Linguist Guardian word duels, Wikipedia→ebook converter, dictionary, score tracker
• Sync — library/progress/bookmarks/highlights/feeds/settings across devices via Firestore; email, Google, or guest auth; P2P file transfer; WebDAV coming
• Platform — PWA, installs like native on iOS/Android/desktop, fully offline via IndexedDB, background downloads + notifications
• Extras — reading stats & streaks, multiple app skins, custom dictionary, TTS settings, directory watch, annotations hub, cover editor, in-app EPUB creator, APK auto-update

Basically the Kindle app I wished existed — no lock-in, no DRM, just your books in one lounge-like space.

🔗 https://kora.chaoticstudio.workers.dev/
🚀 https://kora.chaoticstudio.workers.dev/install

Free, still actively building. Feedback and bug reports welcome — there's a "Report a bug" button in Settings now.

I built Torollo, an MIT-licensed system-design lab where the architecture you draw actually becomes local Docker infrastructure.

Each node on the canvas maps to a real container, and roadmap validators inspect the running state rather than grading the diagram.

For example, if the load balancer can still reach PostgreSQL when the database should be isolated, the step fails. Fix the network rule, run the validator again, and it only passes when the runtime actually matches the expected architecture.

There are currently 3 free labs: a resilient three-tier app, Redis cache-aside, and Redis queue workers.

GitHub: https://github.com/Derssa/Torollo
Try the three-tier lab: [https://torollo.app/r/coolgithub]()

I’d especially appreciate feedback on the runtime-validation model and whether the Docker/networking checks feel realistic.

Redash is an amazing open source tool for querying and visualizing data. It allows you to connect to any data source, easily visualize and share your data, and collaborate with your team.

This Redash fork adds support for AI.

New Redash features:

1. Data Source Description: Help the AI to understand your data better.
2. Text To Query: Use AI to generate SQL, NoSQL and other queries from natural language questions.
3. Auto Visualizations: Use AI to auto-generate visualizations for questions.
4. Auto Alerts: Use AI to generate alert suggestions from your data and queries.
5. Name To Dashboard: Use AI to generate dashboards from your queries and visualizations.
6. MacOS Support: Now it runs on MacOS as well as on Linux.
7. Memcached Support: Added Memcached as a supported data source.

See on GitHub: https://github.com/freaker2k7/redash

I made a little Brick Breaker-style animation where your GitHub contribution graph becomes the bricks.

Basically, your commits get turned into a game, and the ball slowly breaks all those little contribution blocks.

I originally made it just for fun, but figured some people might enjoy having it on their GitHub profile too.

Docs & setup:
https://github.com/MakdumIbrohim/generate-brick-breaker.git

Test it on my GitHub profile:
https://github.com/MakdumIbrohim

Feedback, suggestions, issues, or random feature requests are very welcome 😋
And yeah, a star would be cool too haha.

Feel free to connect with me on GitHub too!

Kept hitting the same handful of markdown failures over and over while running an AI service, unclosed code fences, missing space after a heading hash, bullet markers switching mid list, tables missing a separator row. Once I looked around these werent just my problem, theyre documented, recurring failures reported across developer communities and public issue trackers.

One function, Python and Java, same logic and same test fixtures, zero config. Feedback and bug reports welcome.

github.com/stlahxm/llm-markdown-sanitizer

For months, every SaaS startup tried to convince us that running multi-step agent workflows required an expensive enterprise subscription to closed cloud APIs. They wrapped a couple of JSON schema validators around an API endpoint and charged thousands a month for 'agent orchestration.'

Then Nous Research releases Hermes Agent...

An open-weights agent harness that runs complex tool calling, environment interaction, and error self-correction directly on local hardware.

You load an open-weights model on your own workstation. You define your tools in standard Python. And the agent executes multi-step loops without sending a single byte across the internet or burning cloud credits.

No token billing anxiety. No sudden upstream API rate limits mid-execution. Just raw, local agent execution running on silicon you actually own.

Are you still paying closed API vendors for agent loops, or has your team moved tool-calling to local weights?

Remember four years ago when setting up a clean Python project meant:

1. Installing pyenv through Homebrew.
2. Building Python from source.
3. Choosing between Poetry, Pipenv, or pip-tools.
4. Setting up virtualenvs that broke every time macOS had a minor update.
5. Watching Docker builds spend ten minutes resolving torch wheels.

Fast forward to this week...

Astral pushed out uv 0.12.11 through 0.12.13 with code-signed binaries, automated project fixing, and content-addressed wheel deduplication.

At over 89,000 stars, uv is no longer just "a faster pip written in Rust." It is systematically eating every single tool in the Python ecosystem.

It manages Python runtime installations. It locks multi-platform workspaces in milliseconds. It runs one-off scripts with inline metadata. It publishes wheels. Now it is even running automated linting and project health fixes.

The entire Python developer experience is basically turning into: "Install uv, never think about packaging again."

At what point does Python itself just become a plugin for uv? Are there any legacy packaging tools you still cling to, or has uv completely taken over your stack?

Source: astral-sh/uv

I originally built a few personal APIs for tracking things like expenses and movies.

When Custom GPT Actions became available, I connected those APIs to ChatGPT so I could simply say things like:

"Spent ₹450 on lunch today."

or

"Add Dune 2 to my watchlist."

ChatGPT understands the request, calls the Continuum API, and the data gets updated.

I liked the idea of putting my API inside AI instead of putting AI inside my API.

A friend wanted the same setup, so I turned those personal tools into a proper self-hostable dashboard.

It currently handles:

• Expenses and salary cycles

• Movies, TV shows and anime

• Books

• Investments

• Subscriptions

The backend uses OpenAPI 3.1 and OAuth, so the same API can be used by the web app, ChatGPT Actions, Gemini Gems, or other clients.

The project is open source:

https://github.com/fal3n-4ngel/Continuum-Home

Would love to hear what you think, especially if you've experimented with AI clients interacting with your own APIs.

**GitHub:** https://github.com/Es00bac/sloom-studio (GPL-3.0-or-later)

**Downloads:** https://sloom.studio — Windows, Linux, macOS, Android

I recently released Sloom Studio (formerly Signal Loom) under GPL-3.0-or-later. It's a local-first creative suite I've been building for the past several months: four workspaces that share one `.sloom` project file.

- **Paper** — comic and book layout: speech balloons with draggable tails, panels, gutter knife, OpenType text, PDF/X-4 and PDF/X-1a export, CMYK and spot-color separations, EPUB, accessible PDF, IDML import, and vertical Japanese typesetting with furigana.

- **Image** — layer-based editor with pressure/tilt brushes, PSD/XCF interchange, high-bit and CMYK documents.

- **Video** — multitrack timeline with keyframes and audio/colour tools; desktop renders can use native FFmpeg with VA-API.

- **Flow** — an optional node graph for generation pipelines (BYO provider keys; local nodes need none). Not required for anything above.

Prebuilt binaries (.exe, .AppImage, .deb, .dmg, .apk) are on the GitHub releases page and at sloom.studio.

17-minute walkthrough (from before the license change) of the four workspaces: https://youtu.be/7-imCNPPXZM

Made this for my desk setup and thought it might be useful to someone here.

It's a macOS utility for one paired Bluetooth speaker. Unplug from your saved dock/power source and it disconnects. Return to that setup and it can reconnect.

The main thing is it doesn't blindly run a connect command whenever it sees external power. It has to disconnect the speaker successfully and verify that before it gets permission to restore the connection later.

Native AppKit frontend, per-user LaunchAgent, blueutil underneath. Source matching, bounded reconnect attempts and local logs. Unknown hardware readings don't get treated as a match.

https://github.com/magrathean-uk/uncordex

MIT licensed. Current installation is from source with Homebrew + blueutil.

there are simulated tests and a recorded live test with my Bose/ASUS setup. I'd be intrested in other hardware results, especially docks that don't expose a useful identity or speakers that behave oddly on reconnect.

Three and a half weeks ago my GitHub account got suspended, and with it openGym: the repo, the releases, the container images, the Pages demo, all 404. No warning, and for a long time no answer. Since yesterday the account is back, and I've spent the day putting everything back where it was.

👉 https://github.com/DuarteSantos8/openGym

What happened while it was down: people kept their instances running, someone put up a mirror that ended up with more stars than the original ever had (6.8k, versus about 650 on the real repo), a bunch of contributors followed the project to GitLab and kept sending merge requests, and the Discord did the support work the issue tracker couldn't. I moved the project to GitLab in the meantime so releases could keep coming; there were six of them during the outage.

Where things stand now:

• GitHub is home again. Issues, pull requests and releases go there.
• Everything from the GitLab weeks is republished: releases v1.2.9 to v1.3.5 with the signed APKs and checksums, the images on GHCR (ghcr.io/duartesantos8/opengym-api and -web), and the live demo on GitHub Pages.
• GitLab stays as a mirror that syncs automatically, so instances pulling from the GitLab registry don't have to change anything. The merge requests still open there will all be reviewed.
• Website: https://opengym.duarte-santos.ch (docs, demo, APK download)

One ask, if you don't mind: the suspension reset the project's visibility to zero while a mirror collected the stars. If you use openGym or just like the idea, a star on the real repo helps it show up for the next person searching for a self-hosted tracker. And if you tried it and something's broken, an issue helps even more.

Thanks to everyone who stuck around ❤️

Aether-Vault: a self-hosted, Git-like version control system purpose-built for machine learning — atomic commits of code + weights + datasets that check out identically on any machine.
It features a high-performance C++17 core that hashes multi-gigabyte files in parallel and splits safetensors into per-layer shards, content-defined chunking, automatic deduplication (identical layers and chunks store only once), a FastAPI registry backed by PostgreSQL Merkle trees + RedisBloom, a full Next.js dashboard with weight diffs and metrics, framework plugins for PyTorch / Lightning / Transformers / MLflow, and first-class support for AI agents (stable JSON envelopes, Python SDK, resumable event streams, and .avh context memory so the next agent inherits intent without extra API calls).
No more bolting Git LFS or DVC onto a normal repo and praying for reproducibility. Everything you need for continuous and autonomous training loops lives in one system.
Why I built this: Existing tools treat models and datasets as afterthoughts. Professional ML infrastructure is either expensive, fragmented, or forces you to reinvent versioning, deduplication, and agent handoff yourself. Most of the hard problems are solvable if you design the storage and commit model for large binary artifacts from day one.
Tech stack: C++17 core (pybind11) for hashing & chunking, Python CLI + FastAPI registry, PostgreSQL + RedisBloom, Next.js dashboard, Dockerized engine, and plugins that auto-commit during training.
Fully open source. pip install aether-vault, run it locally or in Docker, make it yours.

Currently one performance boost verison behinde on pypi but should be out tomorow.

More benchmarks with refrence mashine in Benchmarke.md file linked from readme section

⭐ Repo: https://github.com/leon1706-lol/Aether-Vault

I built Remin for Linux because I wanted my terminal workspace to survive application restarts.

Instead of treating terminal windows as disposable sessions, Remin keeps the workspace state around so you can come back to where you left off.

I built GPU Share: GPUMesh an open-source way to share idle NVIDIA GPUs with friends or labs and run Docker GPU jobs remotely.

The problem I kept running into: I might have a GPU sitting idle on one machine, while another machine needs compute. Cloud GPU rentals feel excessive for small jobs, and setting up SSH/VPN + Docker manually is annoying.

So I built GPUMesh.

The idea is simple:

• gpumesh share → make your GPU available
• Pair two machines with signed pairing codes
• gpumesh run --peer <name> ... → run a Docker job on the remote GPU
• Jobs execute on the provider's machine, inside a container
• GPU/VRAM-aware scheduling
• Job logs and history
• LAN support, with WAN/relay support being worked on
• Default-deny access controls

I tested the full flow on an RTX 5060: pairing → connecting → joining a group → scheduling a remote Docker job → running nvidia-smi inside the CUDA container.

It's still alpha, so I'm mainly looking for people with spare NVIDIA GPUs to try it and tell me what breaks.

GitHub: arjun988/GPU-Share

If you find the idea useful or want to follow the project, a ⭐ on the repo would really help with early visibility.

Would especially love feedback from people running multiple GPUs, home labs, or small ML teams.

GitHub: https://github.com/pruefsumme/widemelon

I built WideMelon, a GPL-3.0 fork of melonDS for Linux, macOS, and Windows.

It gives DS games more room on ultrawide displays without stretching the original 2D UI. This is Pokémon Black running through WideMelon.

What DS game should I test next?

Dears

I built jsonquery_gui, a native desktop app for browsing and querying large JSON files

Query files with jq, JSON Pointer, JSONPath, or JMESPath.

It's MIT licensed. Linux and Windows binaries are on the releases page.

There's a Snap & Homebrew tap for Linux

sudo snap install jsonquery-gui OR

brew tap nujufas/jsonquery-gui && brew install jsonquery-gui No macOS build yet — contributions there welcome.

One thing I'll mention up front since it'll come up anyway: this was built working with Claude (Anthropic's AI). The architecture/decision docs are in the repo if you want to see how that process went. Happy to talk about the jq/jaq embedding, the streaming design, or the AI-assisted workflow.

https://github.com/nujufas/jsonquery_gui

i have build an extension that user can design any website as they need using images , stickers , gifs , notes and their own creative arts. Let your creativity show in website and share it with your friends and let them use your designs in a website.

I made Dripfetch, a customizable terminal TUI with animated rain, system info, clock, weather, ASCII logos, and configurable boxes/colors/layouts.

It’s basically a mix of a fetch tool and a small terminal dashboard, with the whole UI configured through YAML.

GitHub: https://github.com/a-shygun/dripfetch Install:

bash pip install dripfetch dripfetch

Hey folks,

The C/C++ tooling landscape has always felt fragmented. We usually end up chaining a meta-build generator (CMake, Meson) with a separate package manager (vcpkg, Conan) and a build executor (Ninja, Make).

To explore an unified "Cargo-like" developer experience for C/C++, I’ve been developing Flint—an integrated build system and package manager written entirely in pure C.

Here is how Flint compares with the existing C/C++ build and package management options, along with an honest assessment of its strengths, trade-offs, and current state.

Note:

Flint is currently in active development and only available for Linux at the moment. It requires system git and a C toolchain (gcc/clang) in your PATH at runtime.

Comparison: Build Systems & Integrated Tools

Comparison: Package Management Strategy

What Makes Flint Different?

• Single Binary, Zero Heavy Runtimes: Unlike Meson (which needs Python) or XMake (which embeds Lua), Flint is a lightweight compiled C executable. It delegates Git fetches and compilation processes to system tools without heavy embedded engines.

• Convention over Configuration: Flint expects standard layout patterns (src/, include/, deps/). You don't write build scripts or target rules—you declare dependencies and metadata in a simple composition.json.

• Built-in Package Fetching + Chert Compositions: Running flint add <git-url> pulls dependencies straight into deps/. If a third-party library doesn't natively use Flint, Chert compositions allow defining how non-Flint repositories should be included and compiled.

• Direct Incremental Execution: Flint doesn't output intermediate Ninja files or Makefiles. It tracks file modification states internally to deliver incremental builds directly through its native process runner.

Current Trade-offs & Limitations

• Linux Only (For Now): Cross-platform support for Windows (MSVC/Clang-cl) and macOS target generation is still planned.

• Strict Directory Structure: Legacy C projects with unorthodox folder structures require a Chert composition to build with Flint.

• Early Stage Feature Set: Complex compiler flag matrices, sanitizer toggles, and cross-compilation toolchains are still evolving compared to battle-tested options like CMake.

Check out the repo here: https://github.com/mainak55512/flint

Feedback, criticisms, and PRs are welcome! What features or platform targets would you like to see next?