2025年12月12日 の Show HN

In other words, an open source decentralized marketplace. But like Carl Sagan said, to make an apple pie from scratch, you must first invent the universe.

So first I had to make open source management systems for every vertical. I'm launching the first one today, Openfront e-commerce, an open source Shopify alternative. Next will be Openfront restaurant, Openfront grocery, and Openfront gym.

And all of these Openfronts will connect to our decentralized marketplace, "the/marketplace", seamlessly. Once we launch other Openfronts, you'll be able to do everything from booking hotels to ordering groceries right from one place with no middle men. The marketplace simply connects to the Openfront just like its built-in storefront does.

Together, we can use open source to disrupt marketplaces and make sure sellers, in every vertical, are never beholden to them.

Marketplace: https://marketplace.openship.org

Openfront platforms: https://openship.org/openfront-ecommerce

Source code: https://github.com/openshiporg/openfront

Demo - Openfront: https://youtu.be/jz0ZZmtBHgo

Demo - Marketplace: https://youtu.be/LM6hRjZIDcs

Part 1 - https://news.ycombinator.com/item?id=32690410

Most email pages contain only one real message, buried under layers of repeated headers/footers. I wanted to rebuild the conversations without all the surrounding noise.

I used an OCR + vision-LLM pipeline to extract individual messages from the email screenshots, normalize senders/recipients, rebuild timestamps, detect duplicates, and map threads. The output is a structured SQLite database that runs client-side via SQL.js (WebAssembly).

The repository includes the full extraction pipeline, data cleaning scripts, schema, limitations, and implementation notes. The interface is a lightweight PWA that displays the reconstructed messages in a phone-style UI, with links back to every original source image for verification.

Live demo: https://epsteinsphone.org

All source data is from the official public releases; no leaks or private material.

Happy to answer questions about the pipeline, LLM extraction, threading logic, or the PWA implementation.

You can either chat directly with the page or add the config to Cursor/Claude to pipe the website/docs straight into your context.

Why MCP? Using MCP is better than raw scraping or copy-pasting because it converts the page into clean Markdown. This helps the AI understand the structure better and uses significantly fewer tokens.

How it works: It is a proxy that fetches the URL, removes ads and navigation, and exposes the clean content as a standard MCP Resource.

Repo: https://github.com/Ami3466/tomcp (Inspired by GitMCP, but for the general web)

Every time I wanted to share something small or unfinished, I opened Twitter and lost 20 minutes to the timeline. Writing a blog post felt too heavy for those smaller, quick thoughts. I just wanted a place to write something down quickly and hit publish.

Jottings is that place. It gives you a clean microblog on a domain you own. Posts show up in simple chronological order. No likes. No followers. No feed trying to decide what matters.

What Jottings is - A microblogging platform that builds fully static microblog sites - A free subdomain (you.jottings.me) or connect your own domain on PRO plans - Markdown, tags, RSS feed, links with preview, and image uploads - An optional AI writing helper when you are stuck or lazy to fix grammar - Optimized for SEO and AI search friendly - Analytics for your sites

What it is not - Not a social network - Not an engagement funnel - Not trying to keep you on the site - Not a replacement for long-form blogging, though you can use it that way

How it works Each Jot publish triggers a static site rebuild. The site is stored in Cloudflare R2 and served directly at the edge. Custom domains go through Cloudflare SSL for SaaS. I built it to be boring, reliable (barring Cloudflare's latest issues), and cheap to run.

Pricing Free tier for a subdomain, text posts, and a lot more. USD5 per month for custom domains, images, full Markdown, and the writing helper. I priced it to be an easy yes.

Limitations - No comments (on purpose) - No native apps yet (iOS is coming) - The writing helper is helpful but not magic - I am a solo founder, so features move at human speed

I use Jottings regularly to document what I build. It has been the lowest-friction way I have found to publish anything publicly.

Demo of Jottings site for product updates: https://jottings.jottings.me/ Demo of my personal Jottings site: https://jottings.vishalvshekkar.com (with custom subdomain)

I would love feedback from this community. What would make this better or more useful for you?

Check it out here: https://jottings.me (2 min set up) Feel free to write to me at [email protected]

— Vishal

Previously was ~540kb, which to be sure wasn't bad, but still felt heavy for a site that's largely text.

The big win was going from Google Analytics to https://umami.is/.

Other pieces in play:

Cookie compliance JS (85kb!) Bootstrap JS & CSS

I built EdgeVec, a vector database that runs entirely in the browser. It implements HNSW (Hierarchical Navigable Small World) graphs for approximate nearest neighbor search.

Performance: - Sub-millisecond search at 100k vectors (768 dimensions, k=10) - 148 KB gzipped bundle - 3.6x memory reduction with scalar quantization

Use cases: browser extensions with semantic search, local-first apps, privacy-preserving RAG.

Technical: Written in Rust, compiled to WASM. Uses AVX2 SIMD on native, simd128 on WASM. IndexedDB for browser persistence.

npm: https://www.npmjs.com/package/edgevec GitHub: https://github.com/matte1782/edgevec

This is an alpha release. Main limitations: build time not optimized, no delete operations yet.

Would love feedback from the community!

I built Verani, an experimental realtime SDK for Cloudflare Actors (Durable Objects).

The goal is to bring a familiar, event-based DX (rooms, emit, channels, lifecycle hooks) to Cloudflare Durable Objects, while handling hibernation correctly.

It focuses on - Socket.io-like semantics on top of Durable Objects - Proper Actor hibernation handling (WebSockets survive, state is restored) - Typed API with explicit tradeoffs.

It’s early and experimental, but functional. I built it mainly to explore DX and state management patterns on Cloudflare Actors, and I’d love feedback from people who’ve built realtime systems or used Durable Objects.

A lot of the dev teams I have worked with had a lot of issues with their documentation. In fact, some of my easiest clients to get were from clients that had "black box" solutions that devs no longer at the company had created. Personally, writing documentation is like grinding nails on a chalkboard.

I have been having a lot of fun with building solutions that can run in a distributed way, not something a dev needs to run themselves. And after a significant amount of testing and building out several different solutions, I finally have a solution that is easy to set up and runs in the background continuously to automate the documentation process.

I'm looking for feedback on a few things: - Ease of onboarding, it should be a simple click -> select repos you want to add. - Quality of documentation, our current free accounts have a standard model compared to premium but the concepts are the same. - Dynamic environments: I tried to make this compatible with any random repo thrown at it.

Let me know your thoughts

Real benchmarks (Dec 12, 2025): - 3.43ms response time (vs 50-200ms industry average) - 337 queries/second (vs 50-150) - 0% error rate, 100% uptime - Constitutional AI with 1,235 specialized "brains"

Built it in 3 weeks. 4 U.S. patents pending.

Full story + independent benchmarks: https://thebrokenwayfoundation.org

Not asking for money. Just need technical validators to verify this is real.

Source is available at: https://github.com/maxpert/marmot/

Most fun part is a Wordpress running in cluster: https://github.com/maxpert/marmot/tree/master/examples/wordp...

Each one of these Wordpress instances is talking to it's own "MySQL" but under the hood replication is being done and stored over SQLite DB.

Runs DuckDB WASM entirely in your browser. No backend, no installation, no signup.

- Query local files (CSV, Parquet, Excel) – data never leaves your machine - Handles 100M+ rows, 50GB+ files in a browser tab - Full UI: Monaco editor, schema explorer, spreadsheet-style results grid - Share SQL via URL – anyone can run your query instantly - BigQuery connector built-in (Snowflake coming)

v0.2 – actively developing. Feedback welcome.

GitHub (MIT): https://github.com/hfmsio/dbxlite

So I've built my own CYOA adventure library.

[1] https://autism-simulator.vercel.app/

Since I use GrapheneOS, I was also missing the "Live Caption" feature from stock Android, so I implemented that too. It runs entirely offline, no data leaves the device.

I built this because I was frustrated with LLM benchmarks potentially being contaminated by training data. When a model scores 99.9% on MMLU-Pro-Max, we can't tell if that's genuine reasoning or memorization.

Forecaster Arena tries to solve this by testing models on events that haven't happened yet—real prediction markets from Polymarket. The ground truth is reality itself, weeks or months later.

How it works:

7 frontier LLMs (GPT-5.1, Claude Opus 4.5, Gemini, Grok, DeepSeek, etc.) (will be updated) -> Each gets $10k virtual capital weekly -> They bet on 500+ real prediction markets -> Bet size = confidence (larger bet = more confident) -> We measure calibration (Brier score) + returns (P/L)

Currently running first cohort (started Dec 7). First statistically significant analysis expected over the next few weeks.

Everything is open source (MIT): https://github.com/setrf/forecasterarena

Happy to answer questions about the implementation or trade-offs I made. Would be great to hear your feedback on the methodology as well!

It's akin to JupyterLite, providing a temporary online Python notebook environment without the need to install any Python packages. It's potentially useful if you need to do a bit of quick interactive work in Python, but don't have the environment set up ready to do so.

Since actual jupyter kernels can't run in pyodide (they run as subprocesses and communicate over ZMQ), it uses an in-process Python kernel which runs on the same interpreter as the application itself.

Notebooks and files can be saved persistently to a local-storage based file system. It uses xterm.js as the terminal emulator (though I'm keen to test out ghostty-web).

[1] https://news.ycombinator.com/item?id=27091167

Why: I wanted a coding assistant that runs locally, with full control over models and data. Copilot is great, but it’s subscription-only and cloud-only. PhenixCode gives you freedom: use local models (free) or plug in your own API keys.

Use the new admin dashboard GUI to visually configure the RAG settings for multi-server management.

Most existing SSRF libraries rely on blacklists or regex checks, which are easy to bypass. dssrf takes a different approach based on normalization, DNS resolution, redirect validation, and IP classification.

Key features: – URL normalization RFC compliant – DNS resolution + IP classification – Redirect chain validation – IPv4/IPv6 safety – Rebinding detection – Protocol restrictions – TypeScript types included

The goal is to eliminate entire classes of classic SSRF vulnerability and it bypasses rather than patching individual payloads.

GitHub: https://github.com/HackingRepo/dssrf-js npm: https://www.npmjs.com/package/dssrf

I love feedback, edge cases, and contributions from the community.

The motivation is personal: at every company I’ve worked at, our data was scattered across warehouses, Slack, GitHub, Asana, and a dozen other tools. I spent way too much time copy-pasting from one source to another just to answer basic questions.

This project is still really early and rough around the edges, but it can already generate dashboards, summaries, and insights without any modeling or setup.

I’m genuinely not sure how useful this is beyond my own workflows, so I’d really love some brutally honest feedback from y'all.

Here’s a short video of it in action if you’re curious: https://www.youtube.com/watch?v=HTp8flEeZao

And you can try it here: app.arka.so

Free to download and use, $9.99 one-time purchase to remove watermark for life.

https://demoscope.app

Would love feedback from anyone doing mobile demos or content creation.

My name is Benjamin and as many developers, I was tired to not succeed my technical interviews, for any reasons.

I made SharpSkill in order to change that.