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

Treat files as individual repositories with qwe

Hi everyone!

I'm stoked to finally release Qwe, a side project that I've been hacking at for the past few weeks.

The Problem Qwe Solves
We all adore Git, but occasionally its project-level tracking can be overkill. Did you ever attempt to revert a single stand-alone config file or a single Python noscript without bothering the rest of the project? Sure, you can do this, but usually, it requires you to use convoluted commands such as git checkout $COMMITHASH -- $FILEPATH and can be needlessly cumbersome.
I created Qwe to make this easier by centering the file as the main unit of version control.

What is Qwe?
Qwe is a Version Control System (VCS) in which you can commit, monitor, and revert files separately with ease.

It's ideal for:
Software developers working with many standalone utility noscripts, configuration noscripts, or build noscripts.
Writers/Documentation Teams versioning Markdown or other text files where each file is a self-contained, independent whole.
Anyone who prefers a more straightforward, file-oriented method of saving history.

Key Features & How It Works
Individual Tracking: Each file is treated as an independent little repository. You don't commit the "project"; you commit the "file."
Simple Reversion: If you break one noscript, you can revert only that noscript to a former state without generating conflicts and touching any other files within your directory.
Built for Speed: Qwe is entirely Golang (GO) written, which keeps the underlying operations efficient and quick. It's compiled to one, static binary.

Try it Out!
I'm a programmer, not a designer, so it's presently a CLI tool, but it's fully working! I'd appreciate it if the community would give it a try and let me have some feedback on the workflow, command layout, and any bugs you discover.

Repo/Download Link: https://github.com/mainak55512/qwe

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

Exploring Vector Databases - Why opensource Cosdata OSS worked for me !

I’ve been exploring different vector databases lately for one of my projects - looking for something that’s fast, efficient, and cost-friendly to set up.

After digging into platforms like Cosdata, Qdrant, Weaviate, and Elasticsearch, I came across this performance comparison .

* Industry-leading 1758+ QPS on 1M record datasets with 1536-dimensional vectors
* 42% faster than Qdrant
* 54% faster than Weaviate
* 146% faster than Elastic Search
* Consistent 97% precision across challenging search tasks

Significantly faster indexing than Elastic Search while maintaining superior query performance.

Cosdata really caught my attention -especially because they offer an open-source edition (Cosdata OSS) that’s easy to experiment with for personal or production projects.

Recently, I joined their community, and it’s been great connecting with other developers who are building and experimenting with retrieval and AI-native systems.

If you’re working on projects involving semantic search, RAG, or retrieval systems, definitely worth checking it out. let me know if you want to join .

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

How we test a compiler-driven full-stack web framework
https://wasp.sh/blog/2025/10/07/how-we-test-a-web-framework

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

Markon • Minimal Distraction‑free Markdown editor
https://metaory.github.io/markon

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

I found a cool discord alternative

So I used to use revolt but they had to rebrand and their phone app got fucked because of it but I found a platform called nerimity that's pretty cool (nerimity.com)

Made a server too if anyone wanted to join it https://nerimity.com/i/XhwTD

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

Show & Tell GroundCrew — weekend build: a multi-agent fact-checker (LangGraph + GPT-4o) hitting 72% on a FEVER slice

TL;DR: I spent the weekend building GroundCrew, an automated fact-checking pipeline. It takes any text → extracts claims → searches the web/Wikipedia → verifies and reports with confidence + evidence. On a 100-sample FEVER slice it got 71–72% overall, with strong SUPPORTS/REFUTES but struggles on NOT ENOUGH INFO. Repo + evals below — would love feedback on NEI detection & contradiction handling.

# Why this might be interesting

It’s a clean, typed LangGraph pipeline (agents with Pydantic I/O) you can read in one sitting.
Includes a mini evaluation harness (FEVER subset) and a simple ablation (web vs. Wikipedia-only).
Shows where LLMs still over-claim and how guardrails + structure help (but don’t fully fix) NEI.

# What it does (end-to-end)

1. Claim Extraction → pulls out factual statements from input text
2. Evidence Search → Tavily (web) or Wikipedia mode
3. Verification → compares claim ↔ evidence, assigns SUPPORTS / REFUTES / NEI \+ confidence
4. Reporting → Markdown/JSON report with per-claim rationale and evidence snippets

>All agents use structured outputs (Pydantic), so you get consistent types throughout the graph.

# Architecture (LangGraph)

Sequential 4-stage graph (Extraction → Search → Verify → Report)
Type-safe nodes with explicit schemas (less prompt-glue, fewer “stringly-typed” bugs)
Quality presets (model/temp/tools) you can toggle per run
Batch mode with parallel workers for quick evals

# Results (FEVER, 100 samples; GPT-4o)

|Configuration|Overall|SUPPORTS|REFUTES|NEI|
|:-|:-|:-|:-|:-|
|Web Search|71%|88%|82%|42%|
|Wikipedia-only|72%|91%|88%|36%|

Context: specialized FEVER systems are \~85–90%+. For a weekend LLM-centric pipeline, \~72% feels like a decent baseline — but NEI is clearly the weak spot.

# Where it breaks (and why)

NEI (not enough info): The model infers from partial evidence instead of abstaining. Teaching it to say “I don’t know (yet)” is harder than SUPPORTS/REFUTES.
Evidence specificity: e.g., claim says “founded by two men,” evidence lists two names but never states “two.” The verifier counts names and declares SUPPORTS — technically wrong under FEVER guidelines.
Contradiction edges: Subtle temporal qualifiers (“as of 2019…”) or entity disambiguation (same name, different entity) still trip it up.

# Repo & docs

Code: [https://github.com/tsensei/GroundCrew](https://github.com/tsensei/GroundCrew)
Evals: evals/ has noscripts + notes (FEVER slice + config toggles)
Wiki: Getting Started / Usage / Architecture / API Reference / Examples / Troubleshooting
License: MIT

# Specific feedback I’m looking for

1. NEI handling: best practices you’ve used to make abstention stick (prompting, routing, NLI filters, thresholding)?
2. Contradiction detection: lightweight ways to catch “close but not entailed” evidence without a huge reranker stack.
3. Eval design: additions you’d want to see to trust this style of system (more slices? harder subsets? human-in-the-loop checks?).

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

GitHub - antoniorodr/Cronboard: A terminal-based dashboard for managing cron jobs.
https://github.com/antoniorodr/Cronboard

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

Spend Less Time Searching, More Time Contributing — GitHub Issue Alerts for open source beginners

Hi everyone,

I recently built a small project aimed at solving one of the biggest problems beginners face when trying to get into open source: finding relevant issues before they are taken.

The problem: Beginners often spend hours searching for suitable issues on GitHub. By the time they find one, it is either too advanced, already assigned, or lacks the beginner friendly labels. This creates unnecessary friction and discourages many from contributing.

The solution I tried: I created a simple tool that monitors any public repositories you choose and notifies you via email or Telegram when a new issue appears that matches your chosen labels. For example, you can track labels like "good first issue" or "frontend" across multiple repositories. The setup is straightforward and can be done within minutes.

Why I think this matters: It saves beginners from wasting time on endless searching, lets them catch issues early, and makes the whole process of contributing less intimidating. It is designed to be minimal and intuitive, without requiring users to manage complex infrastructure or paid services.

Right now this is an MVP. It works, but I want to refine it further. I am looking for:

* Feedback on whether this solves a real pain point for you.
* Suggestions for improvements or additional features that would make it more valuable.
* Thoughts on how this can better serve both contributors and maintainers.

If you have a few minutes, I would really appreciate your insights. Thanks.

[Github Repo](https://github.com/Phoenix1531/IssuePing)

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

My group is creating a website that lets you track your reading, chat with people, and unlock achievements based on your progress!
https://github.com/GRead-Development/GRead

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

OSHPark like service for silicon coming soon. This was a cool talk from the guy starting it.
https://www.youtube.com/watch?v=0nqV9Eo17wA

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

We built open-source infrastructure for autonomous computer using llm agents at scale
https://github.com/LLmHub-dev/open-computer-use

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

I was tired of the "first 20 DMs" chaos, so I built and open-sourced a serverless giveaway tool on Cloudflare's free tier.
https://github.com/promocodequeue/promo-code-queue-hobby

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

Seeking Inspiration: What's a missing open-source tool you'd love to see built?

I'm a developer with some free time and a strong desire to give back to the open-source world. Rather than starting a project based solely on my own needs, I'd love to build something that addresses a genuine need for others.

So, I'm turning to you—the people who live and breathe open-source.

What is a piece of software that you feel is missing from the open-source ecosystem?

I'm casting a wide net. The idea can be related to any domain:

· Developer Tools: A better CLI, a VS Code extension, a testing utility, a new library for a common problem.
· Desktop Applications: A simple, cross-platform note-taking app, a personal finance manager, a dedicated media player.
· Web Apps & Utilities: A privacy-focused alternative to a popular SaaS tool, a self-hostable service dashboard, a specialized content management system.
· System/DevOps: A configuration management tool, a backup solution, a network utility.

The key is that it should be focused and actionable. I'm not building the next Linux kernel, but I am willing to build a robust, well-maintained tool that solves a specific problem well.

Please describe your idea with as much detail as you can. If your idea is the one I choose to build, I will open-source it from day one and gladly credit you for the inspiration.

I'm excited to see what problems you want solved. Thanks for your creativity!

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

Muscle memory or my body as a user

I use a lot of hotkeys. And one of them — fast translate. I select any text in Dutch or Spanish, press the hotkeys on my keyboard, and then read the translation in English on the Google Translate webpage.

My brain and body are familiar with this pattern, so I don't think about it — my hands use this flow through muscle memory.

Yesterday, my hands automatically selected long text in English without paragraphs and pressed the hotkeys. Then I got stuck for a few seconds. The text is already in English, what happened?

Looks like the animal part of my brain uses these hotkeys differently. This is not a translation. This is a way to "make text easy to understand". Long text in English without paragraph breaks is too complicated, and my brain needs "translation" from this format.

Should we create a product based on this via AI/LLM? A tiny number of people use hotkeys at all. Even fewer people use them this way. Almost all people who use these patterns can code and will expect an open-source version, which is hard to earn on.

But it's interesting how my pattern "translate text" was actually "make text easy" all the time.

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

Hey vibe engineers, A good Video Editor maybe?

Since Capcut isn't free and davinci needs 16gb ram what can i use for editing with capcut features.
can a vibe engineer opensource one?

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