I built a tiny open-source, local-first flashcard app after bouncing off Anki’s UI. Looking for feedback/possible contributors

As I was studying for the HL7 v2.8 Control Exam, I looked for a flashcard app. There are a LOT of flashcard apps out there, but they aren't all to my taste.

Anki seems to be the most popular open-source project; however, the UI left something to be desired.
Quizlet seems to have a good user interface, but I was turned off by its ad-heavy, closed setup.
Everything else seemed to be too complex.

So... as a one-week project, I built a tiny flashcard app named BaraBara. I built it with the following in mind:

A single-user experience that runs entirely in the browser.
No accounts or backend! Only `localStorage.`
Decks, with front/back of cards.
Simple "I knew it/I forgot it" spaced repetition.
Static build, you can self-host anywhere.


I'm not trying to compete with Anki/Quizlet. I'm aiming for something smaller and simpler. Thus, the scope is intentionally tiny. I'm sharing it here because:

I'd love some feedback from people who use and develop learning tools.
I'd like to grow this slowly and thoughtfully, and see if this is useful to anyone else.
I'm looking for a few contributors who like working on small projects. This project already attracted one generous contributor, who greatly improved the UI.

🔗Live Demo: [https://barabara.megafarad.com](https://barabara.megafarad.com)

🔗Repo (MIT): [https://github.com/megafarad/barabara](https://github.com/megafarad/barabara)


I'm especially interested in feedback on:

Does the "local only," no back-end approach resonate with you, or do you prefer to have a real back-end from day one?
What is the minimum feature set you expect from an open-source flashcard app (import/export, tags, richer media - like images)?
For anyone who has implemented SRS tools, I simply have two actions on cards: "I knew it," and "I forgot." Is that enough in your view? Additionally, are there any "gotchas" around scheduling, UX, or data modeling that I should know about?


I'm happy to answer any questions about the implementation or direction. If you can see a way for this project to be more useful (or even useful at all!) I'd love to hear it.

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

I got tired of subnoscription-based finance apps, so I built a local-first alternative. I also did it to practice more and for my portfolio.
https://github.com/Jean-EstevezT/Aritmo-Budget-Planner

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

modern opensource smartphone?

I am looking for a modern open source smartphone (hardware)

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

KV and Wide-column database with CDN-scale replication

Building https://github.com/ankur-anand/unisondb, a log-native KV/wide-column engine: with built-in global fanout.

I'm looking forward to your feedback.

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

Tired of Vue toast libraries, so I built my own (headless, Vue 3, TS-first)

Hey folks 👋 author here, looking for feedback.

I recently needed a toast system for a Vue 3 app that was:

modern,
lightweight,
and didn’t fight my custom styling.

I tried several Vue toast libraries and kept hitting the same issues: a lot of them were Vue 2–only or basically unmaintained, the styling was hard-wired instead of properly themeable, some were missing pretty basic options, and almost none gave me predictable behavior for things like duplicates, timers, or multiple stacks.

So I ended up building my own: Toastflow (core engine) + vue-toastflow (Vue 3 renderer).

# What it is

Headless toast engine + Vue 3 renderer
Toastflow keeps state in a tiny, framework-agnostic store (`toastflow-core`), and `vue-toastflow` is just a renderer on top with `<ToastContainer />` \+ a global `toast` helper.
CSS-first theming
The default look is driven by CSS variables (including per-type colors like `--success-bg`, `--error-text`, etc.). You can swap the design by editing one file or aligning it with your Tailwind/daisyUI setup.
Smooth stack animations
Enter/leave + move animations when items above/below are removed, for all positions (`top-left`, `top-center`, `top-right`, `bottom-left`, `bottom-center`, `bottom-right`). Implemented with `TransitionGroup` and overridable via `animation` config.
Typed API, works inside and outside components
You install the plugin once, then import `toast` from anywhere (components, composables, services, plain TS modules). Typed helpers: `toast.show`, `toast.success`, `toast.error`, `toast.warning`, `toast.info`, `toast.loading`, `toast.update`, `toast.dismiss`, `toast.dismissAll`, etc.
Deterministic behavior
The core handles duplicates, timers, pause-on-hover, close-on-click, `maxVisible`, stack order (`newest`/`oldest`), and `clear-all` in a predictable way.
Extras
Promise/async flows (`toast.loading`), optional HTML content with `supportHtml`, lifecycle hooks, events (`toast.subscribeEvents`), timestamps (`showCreatedAt`, `createdAtFormatter`), and a headless slot API if you want to render your own card.

# Quick taste

// main.ts
import { createApp } from 'vue'
import App from './App.vue'
import { createToastflow, ToastContainer } from 'vue-toastflow'

const app = createApp(App)

app.use(
createToastflow({
// optional global defaults
position: 'top-right',
duration: 5000,
}),
)

// register globally or import locally where you render it
app.component('ToastContainer', ToastContainer)

app.mount('#app')

<!-- Somewhere in your app -->
<noscript setup lang="ts">
import { toast } from 'vue-toastflow'

function handleSave() {
toast.success({
noscript: 'Saved',
denoscription: 'Your changes have been stored.',
})
}
</noscript>

<template>
<button @click="handleSave">Save</button>
<ToastContainer />
</template>

# Links

Playground / demo: https://toastflow.adrianjanocko.sk
GitHub: [https://github.com/adrianjanocko/toastflow](https://github.com/adrianjanocko/toastflow)
npm (Vue renderer): https://www.npmjs.com/package/vue-toastflow

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

I just created an open source Reddit Nuke extension!

https://github.com/edoardoCame/RedditNuke

Try it out!

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

n8n vs Nyno (open-source alternative) for Python Code Execution: The Benchmarks and why Nyno is much faster
https://nyno.dev/n8n-vs-nyno-for-python-code-execution-the-benchmarks-and-why-nyno-is-much-faster

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

I built Preso – a free & open-source AI presentation generator (Gamma-like, but OSS)

Hey everyone, 👋
I just launched **Preso**, an **AI-powered presentation generator** that turns prompts, notes, or documents into fully designed slide decks.

**What it does:**

* **Prompt → Deck**: One sentence → researched, structured slides
* **Text → Deck**: Messy notes or articles → clean narrative
* **Doc → Deck**: PDFs / MD / TXT → extracted insights

**Design & Editing:**

* Curated themes (Modern, Luxury Noir, Cyberpunk, etc.)
* AI-generated color palettes
* Fixed **1920×1080 pixel-perfect canvas**
* Drag / resize / rotate elements
* **AI Remix**: edit slides using natural language

**Export:**

* Interactive HTML (standalone)
* PDF, PPTX
* High-res PNGs



**Why I built it:**

I make **a lot of presentations for college assignments**, and Gamma kept hitting limits - restricted exports, locked features, and paywalls for basic things.

I wanted:

* Full control over layouts (not template-locked)
* Proper editing like real design tools
* No usage limits
* Something I could actually extend and improve

So I built **Preso** as a **Gamma alternative**, but **free and open-source**, where AI handles structure and design instead of forcing predefined templates.

This is something I actively use for my own assignments.

**It’s completely free and open-source.**

🔗 Live: [https://preso-ai.vercel.app/](https://preso-ai.vercel.app/)
🐙 GitHub: [https://github.com/atharva9167j/preso](https://github.com/atharva9167j/preso)

Would love feedback - especially on UX, missing features, or performance issues.

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

Challenge Integrate BRSCPP (Non-Custodial Fiat-to-Crypto Payments) in your dApp & Compete for 200 USDC Prize Pool

I am challenging young Web3 developers to integrate BRSCPP (a Non-Custodial infrastructure for Fiat-to-Crypto payments) into their dApps and web stores.

Anyone who successfully integrates, processes payments, or discovers a bug can compete for a 200 USDC prize pool and an option for future project collaboration.

BRSCPP is an MVP project on Sepolia and BSC Testnet developed be me, supporting ETH/BNB, USDC, USDT, and accepting payments in 12 different fiat currencies.

If you are interested, please send a DM.

Regards ;)

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

I built a simple automatic app updater that uses WinGet
https://github.com/ELowry/WinGet-Updater

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

How do you share open source work without it feeling like self-promotion

Hi everyone :),

I’ve been working on a small open source CLI tool in my spare time and recently reached a point where it feels “done enough” to share — but I’m unsure what the right next steps are.

So far I’ve tried:
\- Writing a clear README with examples
\- Adding documentation and usage guides on my docs website
\- Sharing it in one or two relevant discussions (without spamming)

I’m explicitly not trying to market it aggressively — I’d rather get it in front of the right people and receive honest feedback.

For those of you who’ve shipped open source projects that actually got adopted: What made the biggest difference early on? What do you wish you had done sooner?

If it helps, the project it's the link if you have any tips

Thanks!

If you want to check my project out or contribute feel very welcome to do so

https://github.com/Chrilleweb/dotenv-diff

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

koin.js: MIT Licensed WebAssembly Gaming Engine for Retro Games

Hey Open source community!

I released koin.js under MIT license - a comprehensive WebAssembly gaming solution:

What it provides:

• Cross-platform emulation using Emnoscripten-compiled Libretro cores

• React component API for easy web integration

• Performance optimizations including Run-Ahead input processing

• Modular architecture - use just the engine or full UI

• Achievement system integration with RetroAchievements

• Virtual controls with haptic feedback algorithms

Architecture:

• Built on Nostalgist.js with additional performance enhancements

• WebGL rendering with SharedArrayBuffer threading

• Zero runtime dependencies for core functionality

• Comprehensive TypeScript definitions • Browser compatibility focused (Chrome, Firefox, Safari, Edge)



Perfect for: Game preservation, educational tools, indie development, web portfolios.

Contribute today: npm install koin.js

Documentation: https://koin.js.org

Source code: https://github.com/muditjuneja/koin

Join the open-source gaming revolution - your contributions can make web gaming better for everyone!

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

For Linux software maintainers: distropack now supports .tar archives aside from .deb .rpm and .pkg
https://distropack.dev/Blog/Post?slug=introducing-tar-package-support-simple-distribution-without-repository-complexity

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

Help improve Img2Num’s README! (Good First Issue)🦔
https://github.com/Ryan-Millard/Img2Num/issues/106

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

OpenMeters: audio visualization & metering for linux.
https://github.com/httpsworldview/openmeters

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

🌎 Trendgetter v2.0: An API for getting trending content from various platforms
https://github.com/Zivsteve/trendgetter

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

Better issues -> more contributions

If you want more pull requests, start by writing better issues.

From my own experience, on both sides, most people do not avoid contributing because they are lazy. They avoid it because the cost of entry is unclear. You do not know how much context you need or whether you will spend a weekend only to be told that is not what was meant. Clear issues remove that fear and shows respect for the contributor’s time.

The same applies to the codebase itself. If I can clone the repo, run it and understand the basic flow without reverse engineering everything, I am far more likely to help. Poor documentation does not just slow people down. It quietly filters contributors out.

Granularity matters too. Smaller, well scoped issues are simply less intimidating. That first small merge often turns into a second pull request, then a third. Large and fuzzy issues rarely get that first step.

None of this is meant to be flashy or inspirational. I just realized, that after I changed my maintainer habits a bit and followed these guidelines, way more new contributors entered the repo, which is a great feeling :)

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

Isitreallyfoss - Website that evaluates "foss" projects to see if they're as free and open source as advertised
https://isitreallyfoss.com/

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

Kreuzberg v4.0.0-rc.8 is available

Hi Peeps,

I'm excited to announce that Kreuzberg v4.0.0 is coming very soon. We will release v4.0.0 at the beginning of next year - in just a couple of weeks time. For now, v4.0.0-rc.8 has been released to all channels.

## What is Kreuzberg?

Kreuzberg is a document intelligence toolkit for extracting text, metadata, tables, images, and structured data from 56+ file formats. It was originally written in Python (v1-v3), where it demonstrated strong performance characteristics compared to alternatives in the ecosystem.

## What's new in V4?

### A Complete Rust Rewrite with Polyglot Bindings

The new version of Kreuzberg represents a massive architectural evolution. Kreuzberg has been completely rewritten in Rust - leveraging Rust's memory safety, zero-cost abstractions, and native performance. The new architecture consists of a high-performance Rust core with native bindings to multiple languages. That's right - it's no longer just a Python library.

Kreuzberg v4 is now available for 7 languages across 8 runtime bindings:

- Rust (native library)
- Python (PyO3 native bindings)
- TypeScript - Node.js (NAPI-RS native bindings) + Deno/Browser/Edge (WASM)
- Ruby (Magnus FFI)
- Java 25+ (Panama Foreign Function & Memory API)
- C# (P/Invoke)
- Go (cgo bindings)

Post v4.0.0 roadmap includes:

- PHP
- Elixir (via Rustler - with Erlang and Gleam interop)

Additionally, it's available as a CLI (installable via cargo or homebrew), HTTP REST API server, Model Context Protocol (MCP) server for Claude Desktop/Continue.dev, and as public Docker images.

### Why the Rust Rewrite? Performance and Architecture

The Rust rewrite wasn't just about performance - though that's a major benefit. It was an opportunity to fundamentally rethink the architecture:

Architectural improvements:
- Zero-copy operations via Rust's ownership model
- True async concurrency with Tokio runtime (no GIL limitations)
- Streaming parsers for constant memory usage on multi-GB files
- SIMD-accelerated text processing for token reduction and string operations
- Memory-safe FFI boundaries for all language bindings
- Plugin system with trait-based extensibility

### v3 vs v4: What Changed?

| Aspect | v3 (Python) | v4 (Rust Core) |
|--------|-------------|----------------|
| Core Language | Pure Python | Rust 2024 edition |
| File Formats | 30-40+ (via Pandoc) | 56+ (native parsers) |
| Language Support | Python only | 7 languages (Rust/Python/TS/Ruby/Java/Go/C#) |
| Dependencies | Requires Pandoc (system binary) | Zero system dependencies (all native) |
| Embeddings | Not supported | ✓ FastEmbed with ONNX (3 presets + custom) |
| Semantic Chunking | Via semantic-text-splitter library | ✓ Built-in (text + markdown-aware) |
| Token Reduction | Built-in (TF-IDF based) | ✓ Enhanced with 3 modes |
| Language Detection | Optional (fast-langdetect) | ✓ Built-in (68 languages) |
| Keyword Extraction | Optional (KeyBERT) | ✓ Built-in (YAKE + RAKE algorithms) |
| OCR Backends | Tesseract/EasyOCR/PaddleOCR | Same + better integration |
| Plugin System | Limited extractor registry | Full trait-based (4 plugin types) |
| Page Tracking | Character-based indices | Byte-based with O(1) lookup |
| Servers | REST API (Litestar) | HTTP (Axum) + MCP + MCP-SSE |
| Installation Size | ~100MB base | 16-31 MB complete |
| Memory Model | Python heap management | RAII with streaming |
| Concurrency | asyncio (GIL-limited) | Tokio work-stealing |

### Replacement of Pandoc - Native Performance

Kreuzberg v3 relied on Pandoc - an amazing tool, but one that had to be invoked via subprocess because of its GPL license. This had significant impacts:

v3 Pandoc limitations:
- System dependency (installation required)
- Subprocess overhead on every document
- No streaming support
- Limited metadata extraction
- ~500MB+

installation footprint

v4 native parsers:
- Zero external dependencies - everything is native Rust
- Direct parsing with full control over extraction
- Substantially more metadata extracted (e.g., DOCX document properties, section structure, style information)
- Streaming support for massive files (tested on multi-GB XML documents with stable memory)
- Example: PPTX extractor is now a fully streaming parser capable of handling gigabyte-scale presentations with constant memory usage and high throughput

### New File Format Support

v4 expanded format support from ~20 to 56+ file formats, including:

Added legacy format support:
- .doc (Word 97-2003)
- .ppt (PowerPoint 97-2003)
- .xls (Excel 97-2003)
- .eml (Email messages)
- .msg (Outlook messages)

Added academic/technical formats:
- LaTeX (.tex)
- BibTeX (.bib)
- Typst (.typ)
- JATS XML (scientific articles)
- DocBook XML
- FictionBook (.fb2)
- OPML (.opml)

Better Office support:
- XLSB, XLSM (Excel binary/macro formats)
- Better structured metadata extraction from DOCX/PPTX/XLSX
- Full table extraction from presentations
- Image extraction with deduplication

### New Features: Full Document Intelligence Solution

The v4 rewrite was also an opportunity to close gaps with commercial alternatives and add features specifically designed for RAG applications and LLM workflows:

#### 1. Embeddings (NEW)
- FastEmbed integration with full ONNX Runtime acceleration
- Three presets: "fast" (384d), "balanced" (512d), "quality" (768d/1024d)
- Custom model support (bring your own ONNX model)
- Local generation (no API calls, no rate limits)
- Automatic model downloading and caching
- Per-chunk embedding generation

from kreuzberg import ExtractionConfig, EmbeddingConfig, EmbeddingModelType

config = ExtractionConfig(
    embeddings=EmbeddingConfig(
        model=EmbeddingModelType.preset("balanced"),
        normalize=True
    )
)
result = kreuzberg.extract_bytes(pdf_bytes, config=config)
# result.embeddings contains vectors for each chunk

#### 2. Semantic Text Chunking (NOW BUILT-IN)
Now integrated directly into the core (v3 used external semantic-text-splitter library):
- Structure-aware chunking that respects document semantics
- Two strategies:
- Generic text chunker (whitespace/punctuation-aware)
- Markdown chunker (preserves headings, lists, code blocks, tables)
- Configurable chunk size and overlap
- Unicode-safe (handles CJK, emojis correctly)
- Automatic chunk-to-page mapping
- Per-chunk metadata with byte offsets

#### 3. Byte-Accurate Page Tracking (BREAKING CHANGE)
This is a critical improvement for LLM applications:

- v3: Character-based indices (char_start/char_end) - incorrect for UTF-8 multi-byte characters
- v4: Byte-based indices (byte_start/byte_end) - correct for all string operations

Additional page features:
- O(1) lookup: "which page is byte offset X on?" → instant answer
- Per-page content extraction
- Page markers in combined text (e.g., --- Page 5 ---)
- Automatic chunk-to-page mapping for citations

#### 4. Enhanced Token Reduction for LLM Context
Enhanced from v3 with three configurable modes to save on LLM costs:

- Light mode: ~15% reduction (preserve most detail)
- Moderate mode: ~30% reduction (balanced)
- Aggressive mode: ~50% reduction (key information only)

Uses TF-IDF sentence scoring with position-aware weighting and language-specific stopword filtering. SIMD-accelerated for improved performance over v3.

#### 5. Language Detection (NOW BUILT-IN)
- 68 language support with confidence scoring
- Multi-language detection (documents with mixed languages)
- ISO 639-1 and ISO 639-3 code support
- Configurable confidence thresholds

#### 6. Keyword Extraction (NOW BUILT-IN)
Now built into core (previously optional KeyBERT in v3):
- YAKE (Yet Another Keyword Extractor): Unsupervised, language-independent
- RAKE (Rapid Automatic Keyword Extraction): Fast statistical method
- Configurable n-grams

(1-3 word phrases)
- Relevance scoring with language-specific stopwords

#### 7. Plugin System (NEW)
Four extensible plugin types for customization:

- DocumentExtractor - Custom file format handlers
- OcrBackend - Custom OCR engines (integrate your own Python models)
- PostProcessor - Data transformation and enrichment
- Validator - Pre-extraction validation

Plugins defined in Rust work across all language bindings. Python/TypeScript can define custom plugins with thread-safe callbacks into the Rust core.

#### 8. Production-Ready Servers (NEW)
- HTTP REST API: Production-grade Axum server with OpenAPI docs
- MCP Server: Direct integration with Claude Desktop, Continue.dev, and other MCP clients
- MCP-SSE Transport (RC.8): Server-Sent Events for cloud deployments without WebSocket support
- All three modes support the same feature set: extraction, batch processing, caching

## Performance: Benchmarked Against the Competition

We maintain continuous benchmarks comparing Kreuzberg against the leading OSS alternatives:

### Benchmark Setup
- Platform: Ubuntu 22.04 (GitHub Actions)
- Test Suite: 30+ documents covering all formats
- Metrics: Latency (p50, p95), throughput (MB/s), memory usage, success rate
- Competitors: Apache Tika, Docling, Unstructured, MarkItDown


### How Kreuzberg Compares

Installation Size (critical for containers/serverless):
- Kreuzberg: 16-31 MB complete (CLI: 16 MB, Python wheel: 22 MB, Java JAR: 31 MB - all features included)
- MarkItDown: ~251 MB installed (58.3 KB wheel, 25 dependencies)
- Unstructured: ~146 MB minimal (open source base) - several GB with ML models
- Docling: ~1 GB base, 9.74GB Docker image (includes PyTorch CUDA)
- Apache Tika: ~55 MB (tika-app JAR) + dependencies
- GROBID: 500MB (CRF-only) to 8GB (full deep learning)

Performance Characteristics:

| Library | Speed | Accuracy | Formats | Installation | Use Case |
|---------|-------|----------|---------|--------------|----------|
| Kreuzberg | ⚡ Fast (Rust-native) | Excellent | 56+ | 16-31 MB | General-purpose, production-ready |
| Docling | ⚡ Fast (3.1s/pg x86, 1.27s/pg ARM) | Best | 7+ | 1-9.74 GB | Complex documents, when accuracy > size |
| GROBID | ⚡⚡ Very Fast (10.6 PDF/s) | Best | PDF only | 0.5-8 GB | Academic/scientific papers only |
| Unstructured | ⚡ Moderate | Good | 25-65+ | 146 MB-several GB | Python-native LLM pipelines |
| MarkItDown | ⚡ Fast (small files) | Good | 11+ | ~251 MB | Lightweight Markdown conversion |
| Apache Tika | ⚡ Moderate | Excellent | 1000+ | ~55 MB | Enterprise, broadest format support |

Kreuzberg's sweet spot:
- Smallest full-featured installation: 16-31 MB complete (vs 146 MB-9.74 GB for competitors)
- 5-15x smaller than Unstructured/MarkItDown, 30-300x smaller than Docling/GROBID
- Rust-native performance without ML model overhead
- Broad format support (56+ formats) with native parsers
- Multi-language support unique in the space (7 languages vs Python-only for most)
- Production-ready with general-purpose design (vs specialized tools like GROBID)

## Is Kreuzberg a SaaS Product?

No. Kreuzberg is and will remain MIT-licensed open source.

However, we are building Kreuzberg.cloud - a commercial SaaS and self-hosted document intelligence solution built on top of Kreuzberg. This follows the proven open-core model: the library stays free and open, while we offer a cloud service for teams that want managed infrastructure, APIs, and enterprise features.

Will Kreuzberg become commercially licensed? Absolutely not. There is no BSL (Business Source License) in Kreuzberg's future. The library was MIT-licensed and will remain MIT-licensed. We're building the commercial offering as a separate product around the core library, not by restricting the library itself.

## Target Audience

Any developer or data scientist who needs:
- Document text extraction (PDF, Office, images, email, archives, etc.)
-