Embed - Moozonian Search

github.com• Feb 13, 2026• 1 min read

Show HN: C2PA is broken. I fixed it with an adaptive registry and open protocolI built OPP (Open Provenance Protocol), an open standard for verifying whether an image was AI-generated even after screenshots, distortion, pixel fudging, compression, cropping, and re-uploads.The problem: C2PA/Content Credentials embed metadata in the file. Screenshot the image and the provenance is gone. AI detectors are probabilistic and unreliable.OPP takes a different approach, an external fingerprint registry. When a generator creates an image, a 3-layer signature (SHA-256 + PDQ perceptual hash + CLIP ViT-L/14 embedding) is registered in a central index. Anyone can verify an image by querying the index. The signature survives any transformation because it's not embedded in the file. Think Shazam for images, but for provenance.Matching pipeline: exact hash lookup → CLIP cosine similarity via Qdrant HNSW (sub-10ms at billions) → PDQ hamming distance enrichment. Only verified AI generators can mint. Verification is open.The interesting part (new feature): I designed and implemented

github.com• Feb 13, 2026• 1 min read

Show HN: Funxy v0.6 – scripts that ship as standalone executablesHi HN,New release: `funxy build` now produces standalone executables. (Previously I shared the Go embedding — this is the other direction: ship scripts as binaries.) You compile a script, get a binary — bytecode + VM + all deps baked in. No Funxy on the target machine.```bash funxy build server.lang -o myserver scp myserver prod:~/ ssh prod './myserver' ```Embedding: files, directories, glob patterns (`.html`), brace expansion (`.{js,css}`). Everything goes into the binary and is available via `fileRead`, `fileReadBytes`, `isFile` — the script doesn't know if it's disk or embedded.```bash funxy build webapp.lang --embed templates,static --embed "assets/*.css" -o webapp ```Dual-mode: the binary is also a full Funxy interpreter. By default it runs the embedded app. Pass `$` and it switches to interpreter mode — run any script, use `-pe` one-liners, same as regular `funxy`:```bash ./myserver # runs embedded app ./myserver --port 8080 # flags via sysArgs ./myserver $ other.lang # interpret

news.ycombinator.com• Feb 13, 2026• 1 min read

Small Language Models (SLMs) vs. Large Language Models (LLMs)AbstractThe last five years have seen explosive progress in large language models (LLMs) — exemplified by systems such as ChatGPT and GPT-4 — which deliver broad capabilities but at heavy computational, latency, privacy, and cost budgets. In parallel, a renewed research and engineering focus on Small Language Models (SLMs) — compact, task-optimized models that run on-device or on constrained servers — has produced techniques and models that close much of the gap while enabling new applications (on-device inference, embedded robotics, low-cost production). This article/review compares SLMs and LLMs across design, training, deployment, and application dimensions; surveys core compression methods (distillation, quantization, parameter-efficient tuning); examines benchmarks and representative SLMs (e.g., TinyLlama); and proposes evaluation criteria and recommended research directions for widely deployable language intelligence. Key claims are supported by recent surveys, empirical papers,

news.ycombinator.com• Feb 12, 2026• 1 min read

Zero State Architecture deep diveAbëONE's Zero State Architecture: How We Eliminated Drift and Recursive LoopsMost LLMs accumulate context drift over long conversations. AbëONE doesn't. Here's how:*THE PROBLEM WITH STATEFUL AI:*Traditional conversational AI maintains state across turns. This creates: 1. Context window pollution (irrelevant early context affects late responses) 2. Coherence drift (model "forgets" constraints it accepted earlier) 3. Recursive loops (model enters infinite reasoning spirals) 4. Accumulated hallucination risk (errors compound)*ZERO STATE ARCHITECTURE:*AbëONE computes state fresh on every execution:Input → State Reconstruction → Context Retrieval → Fresh Inference → Validation → OutputKey innovations:*1. Declarative State Reconstruction* Instead of carrying forward conversation state, AbëONE reconstructs relevant state from: - User profile embeddings (persistent, user-controlled) - Retrieved context (semantic search over conversation history) - Explicit constraints (re-validated each turn)*

notionpulse.cc• Feb 3, 2026• 1 min read

Show HN: NotionPulse – Track time-on-page for your Notion pagesI’ve been using Notion for sharing documentation and client portals, but I found the lack of engagement metrics frustrating. While some widgets offer simple view counters, they don’t tell me if a user actually read the content or bounced immediately.I built NotionPulse to track actual time-on-page. It works via a minimalist embed that doesn't distract from the Notion aesthetic.Key technical bits: Tracks active tab engagement to ensure the "time spent" is accurate. Minimalist dashboard built with Next.js and Vercel. Working on a sync feature to push these metrics back into Notion DB properties via their API. I’m a solo maker and I’d love to get some technical feedback on the tracking accuracy and the dashboard's utility.Is "time-on-page" a metric you care about for internal docs or public templates?Site: https://www.notionpulse.cc/

news.ycombinator.com• Feb 3, 2026• 1 min read

Show HN: Folion – Local-first Windows file search with a semantic RAG layerHi HN,I’m a solo dev, and after a first push amongst some close friends, I’m finally sharing Folion (https://www.folionapp.com).I built this because I struggle with what I call digital hoarding. My folders are full of files like final_v2_edit.docx and draft_2024_backup.pdf. Tools like Everything are great if I remember the filename, but I usually only remember the concept of what was inside.The Tech & Privacy: Folion indexes your folders locally using a vector store on your machine. I’ve added a RAG-based search engine that operates locally and an LLM layer via AWS Bedrock so you can chat with your files. Your index and embeddings never leave your device; only the specific snippets retrieved for a query are sent to the LLM for response generation.Quick 30-second trailer: https://www.youtube.com/watch?v=94puRu4GMKg (Full 14-min demo on the website).Being Realistic About Limitations: Since this is a solo project, I want to be upfront about what it is and isn't:It’s a Precision Tool: For

news.ycombinator.com• Jan 28, 2026• 1 min read

Ask HN: How to Built an Active CommunityI have built the Tech Content Platform Insidestack (https://insidestack.it) as a new side hustle with currently over 1000 popular RSS Feeds from independent tech experts, tech media houses and Big Tech.The site has some nice features like - Semantic search with text embedding - You can block / follow feeds - You can bookmark and comment articlesThe longterm goal is that any user can build customised feeds by defining interests (which translate into search vectors).I think the site has clean, modern design and is also quite efficient. (warning not vibe-coded). It is fully self-hosted from frontend, backend, database and email.The costs are extremely low currently, I spend less than €20 / month. I want to offer this as completely free service, not even requiring registration, except for creating customised feeds.My question is what is the best strategy to build an active community. I was thinking of open sourcing the feeds to get some attention. But this would be yet another awesome list

github.com• Jan 28, 2026• 1 min read

Show HN: A private, PQ-secure, infinitely scalable blockchain[fully open-source]For the past few months, I’ve been working on a new Layer 1 blockchain designed to solve what I see as the fundamental trilemma in the space: achieving strong privacy, infinite scalability, and post-quantum security simultaneously. The result is NERV: a private-by-default, horizontally scalable blockchain that replaces Merkle trees with 512-byte neural state embeddings, proven inside Halo2 circuits and attested in hardware enclaves. Key technical innovations:Neural State Embeddings Instead of Merkle trees, the entire state of a shard is compressed into a 512-byte vector using a transformer encoder. Transfers are homomorphic updates in this space—no decompression needed. This reduces inclusion proofs by ~900× compared to zkEVMs. Blind Validation & TEE-Bound Privacy Transactions are routed through a 5-hop onion mixer running inside remotely attested enclaves (SGX/SEV/TrustZone). No addresses, amounts, or metadata are ever visible on-chain. Dynamic Neural Sharding Shards split and merge a

github.com• Jan 25, 2026• 1 min read

Show HN: Sara – Markdown-based requirements traceability tool written in RustThroughout my career in embedded systems — automotive (ASPICE), medical, avionics, CMMI environments — I've seen teams struggle with the same problem: requirements traceability. The options were always frustrating:Expensive, heavy tools like DOORS that don't fit modern dev workflows JIRA-based workarounds that slow everything down and integrate poorly with codeSo I built SARA (Solution Architecture Requirements for Alignment): a CLI that treats architecture documents and requirements as a knowledge graph. The core idea: your requirements are too important to be locked in proprietary systems. SARA uses plain Markdown + YAML frontmatter, which means:Full Git workflows (branching, code review, versioning) No vendor lock-in — switch tools anytime, your data stays readable AI/LLM-ready format for automated analysisFeatures:Multi-repo support Traceability queries (upstream/downstream) Validation (broken refs, cycles, duplicates, orphans) Coverage reports and traceability matricesComing soon:

news.ycombinator.com• Jan 24, 2026• 1 min read

Show HN: AI Lint your agents work to build faster and betterI've been using this thing I made called "AI Lint" it's a collection of doctrine, ant rejected anti-patterns that I noticed agents both failing to use and overly leaning into.It's also general patterns for debugging, and architecture to help agents manage complexity in large codebases.It's kind of cool to watch Codex say: "Also, to dig in, I need to follow the repo’s AI Lint rules first. I can start reading those and then inspect the recent changes. Do you want me to proceed?"These are non-syntactic, non-mehanical, opinionated senior engineering wisdom that is tailored to specific languages and frameworks, won of experience, and aiming to let the AI simulate an senior architect's "taste", rather than just hammering away until code "basically works".The problem of AI spaghetti code is real, and it's easier to embed some hard doctrine and rejects into the repo that agents must follow to prevent their nonsense (and reduce time to target) than it is to fix their problems later.Been there,

news.ycombinator.com• Jan 22, 2026• 1 min read

Show HN: SGR – A Linear-Complexity "Living Cell" Outperforming TransformersI am developing an architecture called Sparse Gated Resonance (SGR). It is a sequence modeling approach designed to avoid the quadratic scaling of traditional Self-Attention. I have been benchmarking a 722k-parameter SGR against a 921k-parameter Transformer on Victor Hugo’s "Notre-Dame de Paris" (English).The SGR replaces the attention mechanism with a "Causal Pulse." It uses gated 1D convolutions to generate a navigation vector that resonates against a brain-map of character embeddings. This allows the model to maintain a "Living Cell" state that updates with linear complexity.Full source and implementation: https://github.com/MrPan2048/GeometricTransformer/Benchmarking Data (Notre-Dame de Paris):STEP 3900 ARCH | LOSS | PPL | ENT | TIME SGR | 1.4481 | 4.26 | 1.5476 | 19.0ms STD | 2.0275 | 7.59 | 2.1476 | 40.3msSemantic Comparison (Generation from "Quasimodo"):SGR: "Quasimodo. Then minds that the accasteady which which the" STD: "Quasimododo ng, o uer tre the todo hemo’He wand at tine.

lincolnmaxwell.com• Jan 21, 2026• 1 min read

Show HN: Interactive semantic map and analysis of Hacker News stories in 2025Thought making one of these cluster maps would be interesting. Used Nomic embeddings, HDBSCAN, and UMAP, with Gemma 3 27B (via Ollama) to label the clusters. Looked into the dataset to find the most active posting times, popular domains that were posted, and other trends from this past yearWrite-up and other findings: https://lincolnmaxwell.com/p/clustering-hackernews-2025/Interactive map: https://hackernews-clustered-2025.labs.lincolnmaxwell.com/Heads up: the map is about ~20mb in size (~7mb transfer over network) - don’t use on a metered connectionAMA!

news.ycombinator.com• Jan 17, 2026• 1 min read

I built visual search for tattoo artistsLast year I bought an A2000 for my 10" homelab to experiment with LLMs. Spent months tinkering, mostly just learning how things work.I've been wanting a tattoo, but finding artists sucks. I got a ton of inspiration pics, but every artist I found was in LA or New York.So I built something different. Upload an image or describe what you want, it finds artists whose work matches and shows you where they are.The A2000 ended up as the embedding server. CLIP for visual similarity, pgvector for search, trained style classifier. So far 22k artists, 175k images, 147 cities.https://inkdex.io

rundown.cool• Jan 17, 2026• 1 min read

Show HN Rundown transforms docs into executable workflowsI have been working on this hare-brained scheme to help agents who want to code good and do other things good too.Introducing: Rundown (https://rundown.cool)I think of Rundown runbooks as executable Skills. The Skill provides the detailed context, and the Rundown runbook keeps the agent on track. # Hello ## 1 This is Rundown Rundown transforms markdown into an executable specification. Headings become steps, code-blocks become executable commands. Human-readable. Agent-readable. Machine-executable. ## 2 Guide agents (and humans) through your process Rundown keeps agents on track by injecting precision context at the exact moment it’s needed. ## 3 Make complex workflows deterministic - PASS: CONTINUE - FAIL: GOTO RECOVER Rundown works *with* agents, adding guardrails that enforce transitions and improve accuracy. ## 4 Execute the right commands at the right time - PASS: CONTINUE - FAIL: RETRY GOTO RECOVER Embed commands for automatic execution. Catch failure, retry, and recover graceful

github.com• Jan 15, 2026• 1 min read

Show HN: RagTune – EXPLAIN ANALYZE for your RAG retrieval layerCLI tool to debug and benchmark RAG retrieval without LLM calls.- `ragtune explain "query"` → see what was retrieved with scores - `ragtune simulate` → batch eval with recall/MRR metrics - `ragtune compare` → compare embedders or chunk sizes - CI/CD mode for quality gatesWorks with Qdrant, pgvector, Weaviate, Chroma, Pinecone.Built because I kept guessing why retrieval was bad. Now I can see exactly what's happening.

news.ycombinator.com• Jan 15, 2026• 1 min read

Ran a 5k queries on 50k documents to understand the file vs. vector RAG debatetitle: Ran a 5k queries on 50k documents to understand the file vs vector rag debateWas curious about the noise on file-based RAG as opposed to vector-RAG. So benchmarked Tantivy vs. Chroma to quantify the trade-offs in modern RAG pipelines. I used 5 datasets: CodeXGlue, MS MARCO, SQuAD, HotpotQA, and SciQ.- Indexing/Embedding was 76x slower for Vectors ($O(s)$ vs $O(ms)$). Query latency was 11x slower- In SciQ, keyword search outperformed vectors by 32% (MRR). Terms like "Mitochondria" are specific keys, not semantics. Vectors tended to drift toward semantically similar but factually incorrect answers.- In HotpotQA, I noticed a trend where vectors find the "answer" document but miss the "bridge" document because it isn't semantically similar to the prompt. Finding the right document is not the same as having enough context to prove the answer.The Data (MRR):| Dataset | Domain | Keyword | Vector | Winner || :--- | :--- | :--- | :--- | :--- || CodeXGlue | Code | 0.29 | 0.91 | Vector (+2

matriq.video• Jan 14, 2026• 1 min read

Show HN: I built a semantic search engine for video ("Ctrl+F" for mp4s)Hello HN,I’m David. I built Matriq because I was frustrated with the "Post-Production Scrub."I had hours of B-roll and long-form content, but finding a specific 5-second clip (e.g., "a red car passing by" or "a specific quote about React state") meant manually watching the footage at 2x speed.What I built: Matriq indexes video content visually and aurally. It uses multimodal embeddings to understand scene context, action, and dialogue.The Use Case:While it works for general editing, I’ve found the best use case is Content Repurposing. Creators with 100+ hours of archives can now instantly find "viral hooks" or specific topics to turn into Shorts/Reels without re-watching old footage.It’s in beta. I’d love you to try breaking it or give feedback on the retrieval accuracy.Link: https://matriq.video

news.ycombinator.com• Jan 3, 2026• 1 min read

Show HN: Axion One NeuroSymbolic Microkernel Prototype InRust(Help on Scheduler)Hi HN,I’m the founder of AXION One. We are building a neuro-symbolic microkernel in Rust (Stable 1.78) that attempts to replace heuristic resource allocation with a Vector Symbolic Architecture (VSA) and a Joint Embedding Predictive Architecture (JEPA). The Problem: Running modern AI workloads on Linux leaves policy decisions (scheduling, memory security, energy profiles) to opaque legacy subsystems. You effectively have a black box (the model) running on top of another black box (the kernel), with user-space scaffolding trying to bridge the gap. We argue that sovereign AI requires the kernel itself to be an agent capable of continual learning and verifiable reasoning. The Architecture (The "How"): • VSA (Vector Symbolic Architecture): We encode syscalls as high-dimensional holographic vectors (D=10,000). This allows the kernel to perform symbolic reasoning (e.g., capability verification) using constant-time algebraic operations (binding/bundling) rather than complex branching logic. T

news.ycombinator.com• Jan 3, 2026• 1 min read

Axion One a Neuro-Symbolic Microkernel Prototype in Rust (Help on Scheduler)Hi HN,I’m the founder of AXION One. We are building a neuro-symbolic microkernel in Rust (Stable 1.78) that attempts to replace heuristic resource allocation with a Vector Symbolic Architecture (VSA) and a Joint Embedding Predictive Architecture (JEPA). The Problem: Running modern AI workloads on Linux leaves policy decisions (scheduling, memory security, energy profiles) to opaque legacy subsystems. You effectively have a black box (the model) running on top of another black box (the kernel), with user-space scaffolding trying to bridge the gap. We argue that sovereign AI requires the kernel itself to be an agent capable of continual learning and verifiable reasoning. The Architecture (The "How"): • VSA (Vector Symbolic Architecture): We encode syscalls as high-dimensional holographic vectors (D=10,000). This allows the kernel to perform symbolic reasoning (e.g., capability verification) using constant-time algebraic operations (binding/bundling) rather than complex branching logic. T

news.ycombinator.com• Jan 1, 2026• 1 min read

Atoqu – A Zero‑Dependency, GPU‑Accelerated Search Engine CoreAtoqu is a new open‑source Search Engine Core written in pure C++17 with zero external dependencies.It implements: - Atomic modular architecture - Multi‑mode ranking (Literal, Vector, Hybrid, BM25, Recency, TagBoost) - GPU‑accelerated vector search (CUDA + OpenCL) - Embedding providers (LLM‑ready) - Forward‑compatibility engine (OLFCE) - Full documentation (Doxygen + Sphinx) - CI/CD, sanitizers, static analysisNo Lucene, no JVM, no Python, no FAISS.We’re preparing the v1.2 release and would like community input on:1. *License choice:* Apache v2.0, MPL 2.0, GPLv3, AGPLv3 2. *Performance expectations:* How fast do you think it is vs Google’s core? 3. *Feature priorities for v2.0:* distributed indexing, crawler, query planner, etc.When v1.2 is released, we welcome code review, benchmarks, issues, and contributions.Link to repo will be posted at release.