GroupMQ - An alternative to BullMQ
https://git.new/groupmq

https://redd.it/1o2ihj2
@r_opensource

Looking For Open Source Accounting software (I think?)

Good day all,

I run a sole proprietor business, have basically expenses and income, only for myself and that will never change. I'm looking for a software where I can input all my expenses and the income I generate and then it just prints out the totals for me that I can give to my accountant, I'm sure something like this is really simple but I don't know accounting or billing and I looked at GNUCash but couldn't figure out what I was actually looking at lol, I literally just want to hit "expense -> type expense, location and cost" and then hit "income -> type total, from where" and then at the end of the year I can give the totals to my accountant in a professional manner.

https://redd.it/1o2nuyx
@r_opensource

Built an open-source framework for testing AI agents with semantic validation

Hey everyone!

I've been building AI agents lately and kept running into the same problem: how do you test AI Agents?

I find that manually prompting the Agent for each release is tedious and not scalable, and AI-Evals are still complex to integrate.

To help with this I built an open-source testing framework that uses AI to validate AI endpoints: you define expected behavior and let an LLM judge if the output is semantically correct.

The LLMJudge returns a score (0-1) and reasoning for why it passed/failed.

I built a little landing page and playground to show you my idea (no signups): https://semantictest.dev

The playground runs real LLMJudge validation so you can see how the semantic testing works.

The code is completely open source and you can find extensive documentation here: https://docs.semantictest.dev

Would love feedback from you guys!

Thank you!

https://redd.it/1o2twqd
@r_opensource

Loadouts for Genshin Impact v0.1.11 is OUT NOW with support for Genshin Impact v6.0 Phase 2

# About

This is a desktop application that allows travelers to manage their custom equipment of artifacts and weapons for playable characters and makes it convenient for travelers to calculate the associated statistics based on their equipment using the semantic understanding of how the gameplay works. Travelers can create their bespoke loadouts consisting of characters, artifacts and weapons and share them with their fellow travelers. Supported file formats include a human-readable Yet Another Markup Language (YAML) serialization format and a JSON-based Genshin Open Object Definition (GOOD) serialization format.

This project is currently in its beta phase and we are committed to delivering a quality experience with every release we make. If you are excited about the direction of this project and want to contribute to the efforts, we would greatly appreciate it if you help us boost the project visibility by starring the project repository, address the releases by reporting the experienced errors, choose the direction by proposing the intended features, enhance the usability by documenting the project repository, improve the codebase by opening the pull requests and finally, persist our efforts by sponsoring the development members.

# Updates

Loadouts for Genshin Impact v0.1.11 is OUT NOW with the addition of support for recently released artifacts like Night of the Sky's Unveiling and Silken Moon's Serenade, recently released characters like Aino, Lauma and Flins and for recently released weapons like Blackmarrow Lantern, Bloodsoaked Ruins, Etherlight Spindlelute, Master Key, Moonweaver's Dawn, Nightweaver's Looking Glass, Propsector's Shovel, Serenity's Call and Snare Hook from Genshin Impact Luna I or v6.0 Phase 2. Take this FREE and OPEN SOURCE application for a spin using the links below to manage the custom equipment of artifacts and weapons for the playable characters.

# Resources

[Loadouts for Genshin Impact - GitHub](https://github.com/gridhead/gi-loadouts?ref=gridhead.net)
Loadouts for Genshin Impact - PyPI
[Loadouts for Genshin Impact v0.1.11](https://github.com/gridhead/gi-loadouts/releases/tag/0.1.11?ref=gridhead.net)
Executable for GNU/Linux distributions
[Executable for Microsoft Windows](https://github.com/gridhead/gi-loadouts/releases/download/0.1.11/gi-loadouts-0.1.11.exe?ref=gridhead.net)

# Updates

Artifacts
Night of the Sky's Unveiling
Silken Moon's Serenade
Characters
Aino
Lauma
Flins
Weapons
Blackmarrow Lantern
Bloodsoaked Ruins
Etherlight Spindlelute
Master Key
Moonweaver's Dawn
Nightweaver's Looking Glass
Prospector's Shovel
Serenity's Call
Snare Hook

# Installation

Besides its availability as a *repository package on PyPI* and as an *archived binary on PyInstaller*, Loadouts for Genshin Impact is now available as an *installable package on Fedora Linux*. Travelers using *Fedora Linux 42 and above* can install the package on their operating system by executing the following command.

$ sudo dnf install gi-loadouts --assumeyes --setopt=installweakdeps=False

# Appeal

While allowing you to experiment with various builds and share them for later, Loadouts for Genshin Impact lets you take calculated risks by showing you the potential of your characters with certain artifacts and weapons equipped that you might not even

own. Loadouts for Genshin Impact has been and always will be a free and open source software project, and we are committed to delivering a quality experience with every release we make.

# Disclaimer

With an extensive suite of over 1503 diverse functionality tests and impeccable 100% source code coverage, we proudly invite auditors and analysts from MiHoYo and other organizations to review our free and open source codebase. This thorough transparency underscores our unwavering commitment to maintaining the fairness and integrity of the game.

The users of this ecosystem application can have complete confidence that their accounts are safe from warnings, suspensions or terminations when using this project. The ecosystem application ensures complete compliance with the terms of services and the regulations regarding third-party software established by MiHoYo for Genshin Impact.

All rights to Genshin Impact assets used in this project are reserved by miHoYo Ltd. and Cognosphere Pte., Ltd. Other properties belong to their respective owners.



https://redd.it/1o2v1ks
@r_opensource

Nook Browser, a new WebKit browser is in alpha.
https://www.browsewithnook.com/

https://redd.it/1o2vgqn
@r_opensource

Marketing for Founders: practical resources to grow your project

Hi everyone! Over the last two years I had to figure out how to do marketing to promote my projects.

This meant doing a ton of research and reading a lot and, well… 90% of what you find on the topic is kinda useless, too vague and not actionable, with just a few exceptions here and there.

So I’ve started to collect the best resources in a GitHub repo. It covers topics like:

* Places To Launch Your Startup
* Social Media Marketing
* Sales & Cold Outreach
* SEO
* Email Marketing
* Content Marketing
* Ads
* Influencer Marketing
* Affiliates and Referrals
* Free-Tool Marketing
* Landing Pages, Messaging and Positioning
* Pricing
* Conversion Rate Optimization
* Idea Validation
* User Research



I’m trying to keep it as practical as it gets (spoiler: it’s hard since there’s no one-size-fits-all) and list everything in order so we can have a playbook to follow.

If you're interested you can find it here: [https://github.com/EdoStra/Marketing-for-Founders](https://github.com/EdoStra/Marketing-for-Founders)

Hope it helps!

https://redd.it/1o2vwx0
@r_opensource

Open Source Vision Agents by Stream.
https://github.com/GetStream/vision-agents

https://redd.it/1o2wmzf
@r_opensource

[MIT] Tool to bulk-disable Reddit “Community updates” via Selenium attach (no credential handling)

I open-sourced a small utility to flip Reddit’s “Community updates” to **Off** across all subscribed communities. Motivation: doing it manually is tedious, especially with hundreds of subs.

**Why this approach**

* **Attach to existing browser** via DevTools (`--remote-debugging-port=9222`) so there’s **no credential handling** or API usage—just DOM automation of your own settings page.
* **Resilience**: full pointer/mouse sequence, JS click fallback, shallow shadow-DOM traversal, and state verification via `aria-pressed="true"`.
* **Diagnostics**: optional HTML/screenshot dump on failures.

**Stack**

* Python 3.10+, `selenium>=4.21`.
* Tested on Windows + Chrome/Edge (Chromium). Works elsewhere with small path tweaks.

**Repo / License**

* Code + README: [https://github.com/AarchiveSoft/redditCommunityNotifOffAll](https://github.com/AarchiveSoft/redditCommunityNotifOffAll)
* License: MIT. Issues/PRs welcome—particularly for cross-platform launch helpers, deeper shadow-DOM cases, and CI smoke tests.

If Reddit adjusts the UI, selectors are centralized and easy to tweak. Happy to review PRs for broader locale support and stability improvements.

https://redd.it/1o2wenq
@r_opensource

Built FoldCMS: a type-safe static CMS with Effect and SQLite with full relations support (open source)

Hey everyone,

I've been working on FoldCMS, an open source type-safe static CMS that feels good to use. Think of it as Astro collections meeting Effect, but with proper relations and SQLite under the hood for efficient querying: you can use your CMS at runtime like a data layer.

1. Organize static files in collection folders (I provide loaders for YAML, JSON and MDX but you can extend to anything)
2. Or create a custom loader and load from anything (database, APIs, ...)
3. Define your collections in code, including relations
4. Build the CMS at runtime (produce a content store artifact, by default SQLite)
5. Then import your CMS and query data + load relations with full type safety

# Why I built this

I was sick of the usual CMS pain points:

- Writing the same data-loading code over and over
- No type safety between my content and my app
- Headless CMSs that need a server and cost money
- Half-baked relation systems that make you do manual joins

So I built something to ease my pain.

# What makes it interesting (IMHO)

**Full type safety from content to queries**
Define your schemas with Effect Schema, and everything else just works. Your IDE knows what fields exist, what types they are, and what relations are available.

```typenoscript
const posts = defineCollection({
loadingSchema: PostSchema,
loader: mdxLoader(PostSchema, { folder: 'content/posts' }),
relations: {
author: { type: 'single', field: 'authorId', target: 'authors' }
}
});

// Later, this is fully typed:
const post = yield* cms.getById('posts', 'my-post'); // Option<Post>
const author = yield* cms.loadRelation('posts', post, 'author'); // Author
```

**Built-in loaders for everything**
JSON, YAML, MDX, JSON Lines – they all work out of the box. The MDX loader even bundles your components and extracts exports.

**Relations that work**
Single, array, and map relations with complete type inference. No more `find()` loops or manual joins.

**SQLite for fast queries**
Everything gets loaded into SQLite at build time with automatic indexes. Query thousands of posts super fast.

**Effect-native**
If you're into functional programming, this is for you. Composable, testable, no throwing errors. If not, the API is still clean and the docs explain everything.

**Easy deployment**
Just load the sqlite output in your server and you get access yo your data.

# Real-world example

Here's syncing blog posts with authors:

```typenoscript
import { Schema, Effect, Layer } from "effect";
import { defineCollection, makeCms, build, SqlContentStore } from "@foldcms/core";
import { jsonFilesLoader } from "@foldcms/core/loaders";
import { SqliteClient } from "@effect/sql-sqlite-bun";

// Define your schemas
const PostSchema = Schema.Struct({
id: Schema.String,
noscript: Schema.String,
authorId: Schema.String,
});

const AuthorSchema = Schema.Struct({
id: Schema.String,
name: Schema.String,
email: Schema.String,
});

// Create collections with relations
const posts = defineCollection({
loadingSchema: PostSchema,
loader: jsonFilesLoader(PostSchema, { folder: "posts" }),
relations: {
authorId: {
type: "single",
field: "authorId",
target: "authors",
},
},
});

const authors = defineCollection({
loadingSchema: AuthorSchema,
loader: jsonFilesLoader(AuthorSchema, { folder: "authors" }),
});

// Create CMS instance
const { CmsTag, CmsLayer } = makeCms({
collections: { posts, authors },
});

// Setup dependencies
const SqlLive = SqliteClient.layer({ filename: "cms.db" });
const AppLayer = CmsLayer.pipe(
Layer.provideMerge(SqlContentStore),
Layer.provide(SqlLive),
);

// STEP 1: Build (runs at build time)
const buildProgram = Effect.gen(function* () {
yield* build({ collections: { posts, authors } });
});

await Effect.runPromise(buildProgram.pipe(Effect.provide(AppLayer)));

// STEP 2: Usage (runs at runtime)
const queryProgram = Effect.gen(function* () {
const cms = yield* CmsTag;

// Query posts

const allPosts = yield* cms.getAll("posts");

// Get specific post
const post = yield* cms.getById("posts", "post-1");

// Load relation - fully typed!
if (Option.isSome(post)) {
const author = yield* cms.loadRelation("posts", post.value, "authorId");
console.log(author); // TypeScript knows this is Option<Author>
}
});

await Effect.runPromise(queryProgram.pipe(Effect.provide(AppLayer)));
```

That's it. No GraphQL setup, no server, no API keys. Just a simple data layer: `cms.getById`, `cms.getAll`, `cms.loadRelation`.

# Current state

- ✅ All core features working
- ✅ Full test coverage
- ✅ Documented with examples
- ✅ Published on npm (`@foldcms/core`)
- ⏳ More loaders coming (Obsidian, Notion, Airtable, etc.)

I'm using it in production for my own projects. The DX is honestly pretty good and I have a relatively complex setup:
- Static files collections come from yaml, json and mdx files
- Some collections come from remote apis (custom loaders)
- I run complex data validation (checking that links in each posts are not 404, extracting code snippet from posts and executing them, and many more ...)

# Try it

```bash
bun add @foldcms/core
pnpm add @foldcms/core
npm install @foldcms/core
```

In the GitHub repo I have a self-contained example, with dummy yaml, json and mdx collections so you can directly dive in a fully working example, I'll add the links in comments if you are interested.

Would love feedback, especially around:

- API design: is it intuitive enough?
- Missing features that would make this useful for you
- Performance with large datasets (haven't stress-tested beyond ~10k items)

https://redd.it/1o30i1q
@r_opensource

Did you find any benefit in participating in Hacktoberfest? Application for both contributors and maintainers

It was my curiosity about the potential benefit of participating in these events. I'm very curious about it and would like to know what you think.

https://redd.it/1o2zys3
@r_opensource

NitNab

Introducing NitNab - Nifty Instant Trannoscription Nifty AutoSummarize Buddy

A powerful, open source, privacy-focused native macOS application for transcribing audio files using Apple's cutting-edge Speech framework and Apple Intelligence. Built for macOS 26+ with Swift 6.0 and optimized for Apple Silicon.

https://www.github.com/lanec/nitnab/

https://www.nitnab.com

# ✨ Features

(https://github.com/lanec/nitnab#-features)

# Core Trannoscription

(https://github.com/lanec/nitnab#core-trannoscription)

🎵 Multi-Format Support: M4A, WAV, MP3, AIFF, CAF, FLAC, and more
🌍 Multi-Language: Supports all languages available in macOS Speech framework
⚡ Fast & Efficient: Leverages Apple's on-device SFSpeechRecognizer API
🔒 Privacy-First: All processing happens locally on your Mac
🔄 Batch Processing: Transcribe multiple files in sequence with automatic error handling
📊 Progress Tracking: Real-time progress updates for each file

# AI-Powered Features

(https://github.com/lanec/nitnab#ai-powered-features)

✨ AI Summaries: Generate concise summaries using Apple Intelligence (FoundationModels)
💬 Interactive Chat: Ask questions about trannoscripts, draft emails, extract action items
🤖 Context-Aware: AI maintains conversation history for natural interactions

# Data Persistence & Sync

[](https://github.com/lanec/nitnab#data-persistence--sync)

💾 Auto-Save: Automatically saves audio files, trannoscripts, summaries, and chat history
☁️ iCloud Sync: Built-in iCloud Drive support for seamless device sync
📁 Custom Storage: Choose any folder for local-only storage
🗂️ Organized Structure: Each trannoscription stored in its own timestamped folder
🔄 Cross-Device Ready: Designed for future iOS/iPadOS app integration

# Export & Sharing

(https://github.com/lanec/nitnab#export--sharing)

📤 Multiple Export Formats: Plain Text, SRT, WebVTT, JSON, Markdown
📋 One-Click Copy: Copy trannoscripts, summaries, or chat responses instantly
💾 Flexible Output: Export individual files or batch exports

# User Experience

[](https://github.com/lanec/nitnab#user-experience)

🎨 Beautiful UI: Modern SwiftUI interface with three-tab view (Trannoscript/Summary/Chat)
🖱️ Drag & Drop: Add files by dragging or using file picker
👆 Clickable Files: Select any file to view its trannoscript, summary, or errors
🚫 No Popups: Errors display inline without blocking workflow
🔵 Visual Selection: Blue border highlights selected file

https://redd.it/1o356rt
@r_opensource

Qt 6.10 Released
https://www.qt.io/blog/qt-6.10-released

https://redd.it/1o376wj
@r_opensource

TrustMesh - Open-source reputation layer for AI agents (FastAPI + Python)

Hi r/opensource!

Just open-sourced TrustMesh - a reputation system for AI agents using Bayesian statistics.

What it does: Provides portable trust scores for autonomous AI agents. Think "GitHub stars for agents" - helps evaluate reliability before interactions.

Why it matters: Google's A2A protocol enables agent-to-agent communication, but there's no standard trust layer. This fills that gap.

Tech:

FastAPI backend
Bayesian trust engine (Beta-Binomial modeling)
Python SDK
SQLite (planning PostgreSQL)
MIT licensed

Looking for:

Contributors (especially for TypeScript SDK, web dashboard)
Feedback on the trust algorithm
Integration ideas

GitHub: https://github.com/ashishjsharda/trustmesh

Just launched today - early stage but functional! Check out the API docs at /docs after running locally.

Questions welcome!

https://redd.it/1o37mk5
@r_opensource

Symiosis: a keyboard-driven, notes app inspired by Notational Velocity. With instant search, in-place Markdown rendering and builtin editor (vim/emacs modes).

Hey everyone,

Symiosis is a desktop note-taking app inspired by *Notational Velocity*. It’s built with **Rust + Tauri (backend)** and **Svelte (frontend)**.

**GitHub:** [https://github.com/dathinaios/symiosis](https://github.com/dathinaios/symiosis)

**Key features:**

* Instant search with fuzzy matching
* Markdown rendered in place
* Keyboard-driven (Vim/Emacs modes supported)
* Custom themes and TOML config
* Built-in code editor with syntax highlighting

Currently tested mainly on **macOS** — quick tests suggest it runs on **Windows and Linux**, but I’d love help testing and improving cross-platform packaging.

All Feedback welcome!

https://redd.it/1o3au3d
@r_opensource

Introducing GenosDB: a P2P Graph Database with Built-In Zero-Trust Security

Hi everyone,

I want to introduce GenosDB (GDB), a project I’ve been building. It’s a peer-to-peer, modular graph database designed from the ground up to embed zero-trust security directly into the data layer.

This is not just “another database.” GenosDB is an experiment in combining distributed systems, cryptographic identity, and fine-grained access control into a unified framework where trust is enforced at the edge — without central servers.

# 🔍 The Problem It Tries to Solve

Peer-to-peer systems have always faced a central challenge: how can peers trust each other without relying on a server or central authority?

Typical decentralized apps often end up cheating: they use a P2P database for storage but fall back to centralized servers for identity, authentication, and permissions. That single point of control undermines the decentralization.

GenosDB tries to address this by designing security into the core database engine: every peer, every operation, every role check is verified independently. The network is held together not by trust in servers, but by cryptography and a shared constitution of rules.

[Watch the video](https://www.youtube.com/watch?v=srSmcNLWMus)

# 🧩 Core Architecture

GenosDB is a graph database where data is stored as nodes and edges, and peers can synchronize updates in real time. On top of that, it provides:

* P2P Synchronization – Each instance can connect to others over WebRTC or relays, exchanging updates and applying them locally.
* Eventual Consistency – Updates flow asynchronously, but cryptographic checks guarantee that only valid, authorized changes are accepted.
* Reactive Queries – Peers can subscribe to queries and get real-time updates as the graph evolves.

But the real innovation is the Security Manager (SM), which is not an add-on but an integral part of the architecture.

# 🔒 The Security Manager (SM)

The SM enforces a zero-trust model at multiple levels:

# 1. Identity Management

Every user is an Ethereum address backed by a private key. No passwords are involved. Private keys are protected by:

* WebAuthn – biometric devices, hardware security keys (phishing-resistant).
* Mnemonic phrases – for recovery and portability.

This means authentication is both decentralized and resistant to common attacks.

# 2. Operation Signing and Verification

Every database operation is signed by the user’s active key. When a peer receives an operation:

1. It verifies the signature (authenticity and integrity).
2. It checks the sender’s role and permissions.
3. It rejects the operation if either fails.

Unsigned or tampered operations never enter the system.

# 3. Role-Based Access Control (RBAC)

A hierarchy of roles (guest, user, manager, admin, superadmin) defines permissions like read, write, delete, assignRole.

* Role assignments are stored inside the graph itself, synchronized like any other data.
* Roles can be customized at initialization.
* Authority flows from superadmins, who are defined in the initial configuration.

# 4. Access Control Lists (ACLs)

For more granular control, ACLs can be attached to nodes. For example, a document can explicitly list which peers may read or write it. ACLs are enforced alongside RBAC, so both conditions must be satisfied.

5. Secure Data Storage

When a user stores data through the SM, it is automatically encrypted with a key derived from their identity. Only the rightful owner can decrypt it.

# 🚪 The Zero-Trust Entry Model

One of the hardest problems in zero-trust systems is the bootstrap paradox: how does a brand-new user even join the network if they have no permissions yet?

GenosDB’s solution is a single welcome exception:

* A new address is allowed exactly one operation — creating its own identity node as a guest.
* The system overwrites any attempted role with guest (preventing privilege escalation).
* After that, the user is limited to minimal permissions (read, sync) until promoted by a superadmin.

This creates a secure, one-way entry point. No

shortcuts, no backdoors.

# 🕸 The Distributed Trust Model

Trust in GenosDB is not delegated to a central server. It emerges from three principles:

1. Cryptographic Identity and Signatures Every action is signed. No one can impersonate another.
2. Shared Constitution Rules (roles, permissions) are encoded in the SM and shared across all peers. They are not arbitrary — they are uniform and verifiable.
3. Local Enforcement Each peer checks operations independently. Even if one peer is compromised or malicious, others enforce the rules and reject invalid operations.

This makes the system resilient: a rogue client cannot rewrite its local code to cheat, because other nodes will still reject unauthorized actions.

# ⚖️ Consistency and Security

GenosDB favors security over availability. For example:

* If Bob is promoted to admin by a superadmin, but a lagging node hasn’t received the promotion yet, Bob’s delete operations will initially be rejected.
* Once the promotion arrives, those operations are accepted.

This ensures no operation is accepted without verifiable proof, even if it delays availability slightly.

# 🌍 Why It Matters

Most “decentralized” systems still centralize identity and trust. GenosDB demonstrates that:

* A database itself can carry identity, access control, and trust as first-class citizens.
* P2P apps can enforce zero-trust security without needing external servers.
* Collaborative systems — from shared documents to social platforms to multiplayer games — can be built on a substrate where every action is verified cryptographically.

In short: it’s a database where security is the foundation, not an afterthought.

# 📚 Resources

* [Whitepaper](https://github.com/estebanrfp/gdb/blob/main/WHITEPAPER.md)
* [Documentation](https://github.com/estebanrfp/gdb/blob/main/docs/index.md)
* [API Reference](https://github.com/estebanrfp/gdb/blob/main/docs/genosdb-api-reference.md)
* [Distributed Trust Model](https://github.com/estebanrfp/gdb/wiki/GenosDB-Distributed-Trust-Model)
* [Zero-Trust Security Model](https://github.com/estebanrfp/gdb/wiki/Zero-Trust-Security-Model)
* [Repository](https://github.com/estebanrfp/gdb)
* [Discussions](https://github.com/estebanrfp/gdb/discussions)

# 🙌 Invitation

GenosDB is currently in stable beta. The architecture is functional, the zero-trust flows are enforced, and the P2P engine is running.

I’m sharing this here because I’d love to:

* Experiment with it.
* Stress test it.
* Help shape the roadmap.

If you care about security, decentralization, and real-time collaboration, I’d be thrilled to hear your feedback.

Esteban Fuster Pozzi ([estebanrfp](https://github.com/estebanrfp))

https://redd.it/1o3bz3q
@r_opensource

Gooey - Go WebAssembly UI Framework
https://github.com/cookiengineer/gooey

https://redd.it/1o3dil7
@r_opensource

slop - minimalistic display manager (replacement for login)

Hi everyone,

Recently, I decided to ditch the GUI display manager in favor of the TTY login. However, I was unable to configure the login program the way I wanted so I've decided to build my own.

Introducing [slop](https://github.com/spevnev/slop) \- Simple Login Program.
It is a replacement for getty and login designed to be minimalistic and simple.

Unlike login, which prints a bunch of extra info (date, issue, hostname, motd, etc.), it only displays what is needed for authentication (i.e. prompts from the PAM modules).
Also, it doesn't print an empty line before the prompt like [agetty does](https://github.com/util-linux/util-linux/blob/db0efab5c3e13794ae79fcb3db8371e3af510169/term-utils/agetty.c#L1831).

Features:

* Focus the TTY
* Set command to run on successful login, e.g. `startx`, or a wayland compositor.
* Clear screen after failed attempt
* Set noscript above the prompt
* Predefine a username

Hope this helps someone who wants a simple TTY login.

https://redd.it/1o3f9uw
@r_opensource

JS/TS fetch utilities (and a bit of Go)
https://github.com/fetch-kit/

https://redd.it/1o3eyur
@r_opensource