2025年12月29日 的 Show HN

How small can a language model be while still doing something useful? I wanted to find out, and had some spare time over the holidays.

Z80-μLM is a character-level language model with 2-bit quantized weights ({-2,-1,0,+1}) that runs on a Z80 with 64KB RAM. The entire thing: inference, weights, chat UI, it all fits in a 40KB .COM file that you can run in a CP/M emulator and hopefully even real hardware!

It won't write your emails, but it can be trained to play a stripped down version of 20 Questions, and is sometimes able to maintain the illusion of having simple but terse conversations with a distinct personality.

--

The extreme constraints nerd-sniped me and forced interesting trade-offs: trigram hashing (typo-tolerant, loses word order), 16-bit integer math, and some careful massaging of the training data meant I could keep the examples 'interesting'.

The key was quantization-aware training that accurately models the inference code limitations. The training loop runs both float and integer-quantized forward passes in parallel, scoring the model on how well its knowledge survives quantization. The weights are progressively pushed toward the 2-bit grid using straight-through estimators, with overflow penalties matching the Z80's 16-bit accumulator limits. By the end of training, the model has already adapted to its constraints, so no post-hoc quantization collapse.

Eventually I ended up spending a few dollars on Claude API to generate 20 questions data (see examples/guess/GUESS.COM), I hope Anthropic won't send me a C&D for distilling their model against the ToS ;P

But anyway, happy code-golf season everybody :)

I got tired of Claude Code forgetting all my context every time I open a new session: set-up decisions, how I like my margins, decision history. etc.

We built a shared memory layer you can drop in as a Claude Code Skill. It’s basically a tiny memory DB with recall that remembers your sessions. Not magic. Not AGI. Just state.

Install in Claude Code:

  /plugin marketplace add https://github.com/mutable-state-inc/ensue-skill
  /plugin install ensue-memory
  # restart Claude Code

What it does: (1) persists context between sessions (2) semantic & temportal search (not just string grep). Basically git for your Claude brain

What it doesn’t do: - it won’t read your mind - it’s alpha; it might break if you throw a couch at it

Repo: https://github.com/mutable-state-inc/ensue-skill

If you try it and it sucks, tell me why so I can fix it. Don't be kind, tia

I've been working on a little open source [1] search engine, nilch. I noticed that nearly all well known search engines, including the alternative ones, tend to be run by companies of various sizes with the goal to make money, so they either fill your results with ads or charge you money, and I dislike this because search is the backbone of the internet and should not be commercial, so it runs in a not-for-profit style and aims to survive on donations. Additionally I'm personally really sick of AI in my search results so I got rid of that, and I wanted DuckDuckGo bangs so it supports all of them. Like many alternative search engines, it is fully private.

Sadly, it currently does not have its own index but rather uses the Brave search API. Once I'm in a financial position that it's possible, I would absolutely love to build a completely new index from the ground up which is open source, as well as an open source ranking and search algorithm, to back it.

I posted on Reddit and got an amazing amount of feedback which I implemented a number of feature requests, so I would really like your ideas, critiques, and bug reports as well. Thank you and sorry for the long post!

[1] https://github.com/UnmappedStack/nilch

Hi HN,

Every year, we ask thousands of readers (and authors) to share their 3 favorite reads of the year.

Now you can enter a book/author you love and see what books readers loved who also loved that book/author.

Try it here: https://shepherd.com/bboy/2025

This goes wide and doesn't try to limit itself to the genre, so you get some interesting results.

What do you think?

Background:

I want better recommendations based on my reading history. I'm incredibly frustrated with what is out there.

This system is based on 5,000 readers voting on their 3 favorite reads from 2023 to 2025. So, this covers ~15,000 books and is a high-quality vote. We wanted to keep the dataset small for now while we play with approaches.

We are building a full Book DNA app that pulls in your Goodreads history and delivers deeply personalized book recommendations based on people who like similar books (a significant challenge).

You can sign up to beta test it here if you want to help me with that:

https://docs.google.com/forms/d/1VOm8XOMU0ygMSTSKi9F0nExnGwo...

The first beta is coming out in late January, but it's pretty basic to start.

Past Show HNs as we've built Shepherd:

https://news.ycombinator.com/item?id=40084193

https://news.ycombinator.com/item?id=38600246

https://news.ycombinator.com/item?id=26871660

Thanks, looking forward to your comments :)

Ben

Most S3 usage is PUT, GET, DELETE, LIST with basic auth. This does exactly that.

SigV4 auth, multipart uploads, range requests. Storage is just files on disk.

No versioning, no ACLs, no encryption. Use MinIO or AWS if you need those.

Hi HN,

I’m a solo dev building a clinical search engine to help my wife (a resident physician) and her colleagues.

The Problem: Current tools (UpToDate/OpenEvidence) are expensive, slow, or increasingly heavy with pharma ads.

The Solution: I built Evidex to be a clean, privacy-first alternative. Search Demo (GIF): https://imgur.com/a/zoUvINt

Technical Architecture (Search-Based RAG): Instead of using a traditional pre-indexed vector database (like Pinecone) which can serve stale data, I implemented a Real-time RAG pattern:

Orchestrator: A Node.js backend performs "Smart Routing" (regex/keyword analysis) on the query to decide which external APIs to hit (PubMed, Europe PMC, OpenAlex, or ClinicalTrials.gov).

Retrieval: It executes parallel fetches to these APIs at runtime to grab the top ~15 abstracts.

Local Data: Clinical guidelines are stored locally in SQLite and retrieved via full-text search (FTS) ensuring exact matches on medical terminology.

Inference: I’m using Gemini 2.5 Flash to process the concatenated abstracts. The massive context window allows me to feed it distinct search results and force strict citation mapping without latency bottlenecks.

Workflow Tools (The "Integration"): I also built a "reasoning layer" to handle complex patient histories (Case Mode) and draft documentation (SOAP Notes). Case Mode Demo (GIF): https://imgur.com/a/h01Zgkx Note Gen Demo (GIF): https://imgur.com/a/DI1S2Y0

Why no Vector DB? In medicine, "freshness" is critical. If a new trial drops today, a pre-indexed vector store might miss it. My real-time approach ensures the answer includes papers published today.

Business Model: The clinical search is free. I plan to monetize by selling billing automation tools to hospital admins later.

Feedback Request: I’d love feedback on the retrieval latency (fetching live APIs is slower than vector lookups) and the accuracy of the synthesized answers.

OP here.

Most Deep Learning approaches for TSP rely on pre-training with large-scale datasets. I wanted to see if a solver could learn "on the fly" for a specific instance without any priors from other problems.

I built a solver using PPO that learns from scratch per instance. It achieved a 1.66% gap on TSPLIB d1291 in about 5.6 hours on a single A100.

The Core Idea: My hypothesis was that while optimal solutions are mostly composed of 'minimum edges' (nearest neighbors), the actual difficulty comes from a small number of 'exception edges' outside of that local scope.

Instead of pre-training, I designed an inductive bias based on the topological/geometric structure of these exception edges. The agent receives guides on which edges are likely promising based on micro/macro structures, and PPO fills in the gaps through trial and error.

It is interesting to see RL reach this level without a dataset. I have open-sourced the code and a Colab notebook for anyone who wants to verify the results or tinker with the 'exception edge' hypothesis.

Code & Colab: https://github.com/jivaprime/TSP_exception-edge

Happy to answer any questions about the geometric priors or the PPO implementation!

I didn't realize Universe Sandbox ran on MacOS, and I was in the mood to play around a bit.

Some functions it's got: - Random system generation - Sonification is super fun too - Habitability Simulation (Just for fun, don't cite this please) - Replacing, spawning, deleting objects

I've had tons of fun building this, so I hope someone else can share the joy. It's free and runs in the browser.

I'd love to hear any feedback. I think this is at a state where I might leave it as it is, but if people are interested in other features, maybe I'll keep working on it. I've kept saying I'll stop working on this for a while now though.

An older family member showed me these puzzle games that he was playing via YouTube videos. I wanted to make them more playable in a frictionless way, so I generated all possible combinations for these types of puzzles and put together an interface for them.

Is the service down? Check in seconds if it's just you or everyone else.

Here's why two Millennium Prize Problems—one about prime numbers, one about fluid dynamics—are secretly the same:

*The Setup:*

The functional equation ξ(s) = ξ(1-s) identifies σ with 1-σ. Topologically, this turns the critical strip into a *torus*. The critical line σ = ½ is the *throat*.

Now treat ξ(s) as a stream function. Its gradient is a velocity field. The flow is automatically: - *Incompressible* (ξ is holomorphic → Cauchy-Riemann → ∇·v = 0) - *Symmetric* (functional equation → v(σ) = v(1-σ))

*The Connection:*

| Zeta Function | Fluid Dynamics | |--------------|----------------| | ξ(s) | Stream function | | \|ξ\|² | Pressure | | Zeros of ξ | Pressure minima (p = 0) | | σ = ½ | Torus throat |

*The Theorem:*

For symmetric incompressible flow on a torus, *pressure minima must lie on the symmetry axis*.

Why? A symmetric function p(σ) = p(1-σ) can only have a unique minimum at σ = ½.

Zeros are pressure minima → zeros at σ = ½ → *Riemann Hypothesis*.

*Now for Navier-Stokes:*

Beltrami flows (where vorticity ∥ velocity, i.e., ω = λv) have a similar structure. The vortex stretching term—the thing that causes blow-ups—becomes:

``` (ω·∇)v = (λv·∇)v = (λ/2)∇|v|² ```

That's a *gradient*. Gradients have zero curl: ∇ × (∇f) ≡ 0.

No curl contribution → no vorticity growth → *no blow-up*.

*The Punchline:*

Both problems are: *"Given a symmetric structure on a torus, prove things concentrate at the throat."*

- RH: Zeros (pressure minima) → throat (σ = ½) - NS: Flow (enstrophy) → Beltrami manifold (no blow-up)

Same geometry. Same mechanism. Same problem.

[Interactive visualization](https://cliffordtorusflow-git-main-kristins-projects-24a742b...)

*What I verified:* - 40,608+ points with certified interval arithmetic - 46 rigorous tests pass - Pressure minima all at σ = 0.500 - Enstrophy bounded (ratio = 1.00)

*Repository:* https://github.com/ktynski/clifford-torus-rh-ns-proof

*Paper:* [18-page proof](https://github.com/ktynski/clifford-torus-rh-ns-proof/blob/m...)

Either I've found a deep connection, or I've made an error that connects two unrelated problems in the same wrong way. Both would be interesting.

NSFW AI Image removes the barriers to creative freedom. While mainstream tools restrict content and local models require expensive hardware, NSFW AI Image offers a seamless, browser-based solution for uncensored generation.

Key Features:

Truly Free: No paywalls, subscriptions, or daily credit limits.

No Login Required: Start generating immediately without providing an email or personal data.

No GPU Needed: All processing happens in the cloud, allowing you to generate images on any laptop or mobile phone.

Uncensored Capabilities: specifically tuned to understand and visualize prompts that are blocked by standard AI services.

Whether you are looking for a lightweight alternative to Stable Diffusion or just want to test prompts quickly, NSFW AI Image provides a private and accessible platform for adult AI art.

WebAssembly makes it possible to run serious computation in browsers. I wanted to see if we could treat browsers as Kubernetes workers.

Kuack is a Virtual Kubelet provider that schedules Kubernetes workloads to browser tabs. Visitors' browsers connect, report capacity, and become ephemeral workers. It looks like a regular Kubernetes node - same kubectl commands, same OCI images, same workflows. The difference is that pods execute in browsers instead of servers. With multi-platform OCI images, Kubernetes can fall back to regular nodes if no agents are available.

It's designed for short-lived, stateless, CPU-heavy jobs: load testing from real networks, local data preprocessing, edge computing scenarios, machine learning tasks, etc.

Not a replacement for your cluster - just an extra option for workloads that benefit from browser execution.

We often find ourselves waiting for Excel just to do simple tasks like merging two CSVs, checking for duplicates, or converting a PDF table to CSV.

Thus, I built ilovecsv.net.

It's a suite of 30+ free tools that run in your browser.

Hacker News has been my homepage and my inspiration for many years. While I’m still learning the ropes of building a public website, I created DreyX.com out of a simple necessity: I wanted a better way to track AI news without all the fluff. Literally a tool built by a curious reader, for curious readers. Thoughts? Suggestions?

Lobste.rs makes its entire invitation tree public. I scraped it and built this interactive visualization.

Some interesting patterns:

- The top 10 inviters are responsible for ~40% of all users.

- The tree is surprisingly shallow: Most users are only 4-6 generations from the founder. Max depth is around 15.

Built with Sigma.js for WebGL rendering. Works on mobile too.

(I am seeking a lobste.rs invite if anyone's willing! – my email is in my profile)

Hi,

I whipped up this daily piano challenge game after noticing my partner struggling to play a tune by ear. She could hum the tune, but was struggling with recognizing whether the next note would be higher or lower than the previous.

That gave me the idea of KeyByKey. A simple Wordle-style daily challenge game, where you are given a tune to play back by ear.

There's no limit to the number of attempts, but after successfully completing the challenge it will show how you compare to other players.

Still ironing out some bugs.

Let me know what you think!

Hi HN, I'm Max.

I built this because I was terrified that if I die tomorrow, my family gets nothing. The existing solutions were either trusting a centralized custodian or complex hardware setups.

Shardium is a client-side tool that splits your seed phrase into 3 shards using Shamir's Secret Sharing.

Shard A: You keep.

Shard B: You give to a beneficiary (PDF).

Shard C: We hold (or you self-host).

It works as a dead man's switch: If you are inactive for 90 days (email ping), Shard C is released to your beneficiary. They combine B + C to recover the funds.

The Stack:

secrets.js-grempe for the math.

FastAPI + PostgreSQL backend.

Client-side encryption (seed never hits the network).

It is 100% Open Source and MIT Licensed. You can self-host it for free ($0), or use the managed version.

I'd love your feedback on the security model. Roast my code here: https://github.com/pyoneerC/shardium

We’re building a real-time mirror of collective thinking.

Awaaz is a social insights platform where people anonymously vote on meaningful questions—about society, culture, relationships, work, politics, and everyday life—and instantly see how others think.

No followers. No performative opinions.

Just honest signals.

Unlike traditional social media that rewards the loudest voices, Awaaz is designed for quiet truth: structured questions, genuine responses, and clear visual insights that reveal patterns in human thought.

What makes it different:

Anonymity-first → reduces social pressure and virtue signaling

Signal over noise → votes, not debates

Psychological safety → opinions without backlash

Collective intelligence → every vote improves the data

At its core, Awaaz taps into a simple human drive: “How do others really think—and where do I stand?”

We believe curiosity, self-reflection, and belonging are timeless needs. When designed well, they don’t get boring.

Building this with a small team, strong conviction, and a long-term view.

If you’re interested in social data, human behavior, or products that prioritize depth over dopamine—happy to connect.

I built Meter to keep scraped website content in sync over time.

Meter uses an LLM once to generate a scraping plan, then runs entirely on raw HTTP requests (no Selenium, no LLMs) to periodically detect changes and re-extract content.

I built it after spending years writing custom scrapers: parsing sites, wiring the output into databases, and keeping everything working as pages evolved. Meter follows the same approach I use in practice — do heavy analysis up front, then run fast, cheap scrapes continuously.

I’m really interested to hear from people maintaining scraping jobs or RAG pipelines in this context. I’d love any feedback on the product - thanks!

Hi HN, I built a native macOS app for helping interviewers for writing feedbacks. It listens to realtime conversations, takes the code, you can add your custom rules and BOOM, it will write the feedbacks in a way you want.

My cofounder and I have been building a persistent storage engine designed specifically for edge robotics and embodied systems.

The core problem we set out to solve was the reliability gap in local data logging. In our experience with autonomous systems, the most critical sensor logs often get lost when a robot loses power because that data is still sitting in the OS page cache waiting to be flushed. This often forces teams to rely on expensive real time cloud streaming just to ensure data safety.

We built an engine that solves this by bypassing the Linux kernel cache entirely and streaming data directly to NVMe. This approach unlocks several key capabilities for edge devices.

First it guarantees that every frame is physically persisted to disk the instant it is captured with under 1 microsecond write latency. Second it significantly increases your available RAM capacity by preventing the kernel from filling memory with write buffers allowing you to run larger models locally. Finally it allows you to reduce cloud dependency and bandwidth costs because you can actually trust your local storage to survive a hard power cut.

We put together a short video to demonstrate this in real time showing a side by side comparison of a standard logger versus our engine during a hard power cut.

This is likely most useful for engineers working on autonomous vehicles, industrial robotics, or any edge application where losing the last few seconds of data before a crash makes debugging impossible.

If you are running into these bottlenecks or just want to stress test the claims drop us a message and we will send you the binary to play around with.

Build Dockmate - Docker/Podman containers manager TUI application in Go using bubble-tea TUI framework.

Features:

- Container management (start/stop/restart/remove, logs)

- Real-time container monitoring (CPU, memory, disk I/O, etc.)

- View/Hide columns (Memory, Cpu, Net I/O, etc.)

- Compose project grouping

- Podman runtime support (switch easily)

- Persistent settings (YAML config)

- Info/Help panels with shortcuts

- Configurable Interactive Shell (/bin/sh, /bin/bash, etc.)

- Homebrew support

- One command-line installation

Works on both Linux and macOS!!

Demo Gif: https://github.com/shubh-io/DockMate/blob/main/assets/demo.g...

Github: https://github.com/shubh-io/DockMate

Hi HN,

Here is a late Christmas present: I rebuilt Neko [1], the classic desktop cat that chases your mouse, as a tiny, dependency-free JavaScript library that runs directly on web pages.

Live demo: https://louisabraham.github.io/nekojs/

GitHub: https://github.com/louisabraham/nekojs

Drop-in usage is a single script tag:

    <script src="https://louisabraham.github.io/nekojs/neko.js" data-autostart></script>

This is a fairly faithful recreation of Neko98: same state machine, same behaviors, same original 32×32 pixel sprites. It follows your cursor, falls asleep when idle, claws walls, and you can click it to cycle behavior modes.

What made this project interesting to me is how I built it. I started by feeding the original C++ source (from the Wayback Machine) to Claude and let it "vibe code" a first JS implementation. That worked surprisingly well as a starting point, but getting it truly accurate required a lot of manual fixes: rewriting movement logic, fixing animation timing, handling edge cases the AI missed, etc.

My takeaway: coding agents are very useful at resurrecting old codebases, and this is probably the best non-soulless use of AI for coding. It gets you 60–70% of the way there very fast, especially for legacy code that would otherwise rot unread. The last 30% still needs a human who cares about details.

The final result is ~38KB uncompressed (~14KB brotli), zero dependencies, and can be dropped into a page with a single <script> tag.

Happy to hear thoughts from desktop pets nostalgics!

[1]: https://en.wikipedia.org/wiki/Neko_(software)

I built Synx, a real-time temperature and humidity monitoring system that bridges hardware, systems programming, and modern web dev.

Architecture: - ESP8266 + DHT11 sensor sending data via MQTT - Go backend for data ingestion, writing to InfluxDB (time-series DB) - Next.js frontend with live WebSocket updates (zero latency) and historical charts

Key engineering decisions: - MQTT over HTTP for true real-time push - Server-side timestamping (ESP8266 has no RTC) - InfluxDB for efficient time-series storage - Dual-channel: WebSocket for live data, REST API for history

I built this as a junior Go engineer to move beyond CRUD apps and work with IoT protocols, systems programming, and real-time data streaming.

Would love feedback on the architecture choices!

Hey HN! I forked an fun little extension that plays GTA mission failed/passed sound and displays banner based on Leetcode solution submissions.Try it out and have a laugh in the grind!

Hey guys, I built an app that follows the envelope budgeting philosophy like YNAB and with beautiful expense breakdown displayed in sankey, line, bar charts.

It also tracks your crypto wallet (BTC & ERC20), bank connections through Plaid and brokerage accounts through SnapTrade.

Create unlimited categories, cash/loan/credit accounts and start budgeting at https://buildyourbudget.com/

As a game designer, I had been working on variety indie game ideas for some time now. But little did I know that what had started as musings with friendly co-op, platformers, & even endless runners almost 2 years back, would leave me with two deeper questions:

1. Why “video” games? And when I ask this, the implication is not a critical take on videogames. Rather, it’s an amazement at the stagnation in the gaming industry, as users are fed similar dizzying experiences over and over. Should a playful online recess require eye-numbing photorealistic graphics as a quintessential?

2. What are the players taking away from this? Clearly, my despair with the existing visuals-heavy gaming experience was leading me somewhere - the question of what else, feels broken? Mechanics… yeah, the videogame mechanics of frantic clicks & keys seem to be almost the same since the time of arcade! In fact, they seem motivated by the shared ideals of driving addiction as symptom of heightened dopamine & adrenaline. In the blazing world of SM & apps already hijacking one’s brain’s receptors, this didn’t feel right. Worse, most videogames now feel like a recipe to fry those dopamine receptors up. No wonder, cozy games are becoming THE thing now. Though even among cozy titles, it was hard to find one that had dared to go beyond the normative ideas of a videogame.

BLUEGRASS: MINDFULNESS SIMULATOR And so, I dared. I worked full-time on a spatial-audio ASMR gaming experience that simulates the human mindfulness process, and put up the demo on Steam! As someone whose wellness - both mental & physical - has been wonderfully enriched by the mindfulness practices I learnt at the foothills of the Himalayas in India, I felt that sharing the gift of this demo might be the worthwhile thing to do this New Year.

Did you know that a standard Microsoft Project 2024 license costs a staggering €929.00 (for just one user)? It’s the absurdity of modern communication. In my workplace, MS Project files are sent back and forth via email, and only those with Project or Delivery Manager roles can actually access the plan without relying on exports or screenshots. In an era of OKRs and the push for clear, transparent, and motivating team objectives, many companies still make it difficult, if not impossible, to see the "big picture." That is why I’ve decided to take my experiments with AI and "vibe coding" to the next level. Introducing www.airtaskpm.com (2), an online tool designed to manage traditional project plans in both table and Gantt formats. At your pace: Full automatic scheduling. Breaking barriers: Cloud-based collaboration for the entire team. Respecting the past: One-click MS Project import. Baselines: Create plan versions and visualize real "slippage" between them instantly. Sovereignty & Privacy: 100% hosted in Europe (GDPR compliant). A "delete everything forever" button is always at hand.

Care to join the beta and give me your feedback?

(1) https://lnkd.in/eQBj3cVy (2) https://www.airtaskpm.com

Hi HN,

I built diff-journal, a small Node.js library for append-only, diff-based journaling of file changes with deterministic replay and rollback.

The core idea is simple:

every file change is recorded as an immutable journal entry (unified diff)

the journal is the single source of truth

files on disk are derived artifacts that can always be rebuilt

This is especially useful for automated or AI-generated file changes, where you want:

strict auditability

deterministic replay (no heuristics, no “best effort” undo)

the ability to materialize any past state by sequence number

It’s intentionally not a VCS and doesn’t try to replace Git.

Repo: https://github.com/svenschaefer/diff-journal

npm: https://www.npmjs.com/package/diff-journal

Feedback very welcome.

The current pricing for crypto data APIs (CoinGecko/CMC) is based on a legacy requirement: maintaining hundreds of real-time websocket connections to centralized exchanges (Binance, Coinbase, Kraken, etc.).

That infrastructure is heavy, expensive, and requires constant maintenance to filter wash-trading and normalize order books.

But if you are building for DeFi, that data is technically irrelevant. The "real" executable price is on-chain (Uniswap, Raydium, Curve).

I realized that if I just ignored the CEXs entirely and only indexed the blockchain, I could drop the cost basis by an order of magnitude.

So I built qoery.com

It indexes DEX logs directly from RPC nodes. It doesn't touch centralized exchange data.

The Trade-off: If you need global VWAP (Volume Weighted Average Price) including Binance/Coinbase, this API is useless to you. If you need the actual on-chain price for a dApp or wallet, this is the exact same data as the big guys, but ~85% cheaper (starts at $3.99 vs ~$35).

I’m curious if there are edge cases I’m missing where a DeFi app would strictly require off-chain CEX data?

Hey HN,

I built agtrace because I kept losing track of what was happening in my Claude Code sessions – context pressure, tool calls, costs.

It's basically `top` for AI coding agents: - Live dashboard showing context window usage and activity - Session history you can query and diff - Works with Claude Code, Codex, and Gemini CLI - 100% local, reads existing logs, no cloud

Install: `npm i -g @lanegrid/agtrace`

The core idea is pointer-based indexing (no log duplication) and schema-on-read (resilient to provider schema changes).

Would love feedback, especially from heavy Claude Code / Codex users.

Hi HN,

I kept getting annoyed having to track down which process was sitting on a port so I could kill it, so I built a tiny CLI tool that shows you exactly what’s using a given port and having the option to kill it. Sharing it here in case it helps someone else too.

I’ve been experimenting with an AI-assisted approach to detecting patterns in network traffic.

For context, I maintain a project called Phone Home Detector, which analyses traffic between IP address pairs. It aggregates traffic into one-minute buckets and applies a set of fixed rules based on byte counts and transmission intervals.

I recently prototyped an extension that exposes transmission size and timing data through an MCP tool, making it queryable by an LLM. The goal is to explore whether an LLM can identify patterns that are difficult to capture using static rules alone.

This work is still experimental, and I’m not yet convinced it is an improvement over fixed-rule approaches. That said, I do find it interesting, and it may be a foundation for further exploration. The following is an example of a summary that it generates:

The data sizes sent to IP address 91.189.91.49 are mostly consistent at 200, after an initial size of 168, and the intervals at which they are sent vary without any apparent pattern.

Hi, I built Stos because I wanted a dedicated app for browsing StackOverflow without the distractions of browser. It's built using Compose Multiplatform, which allowed me to share code across platforms.

I'm curious to hear what you think about this app. Feedback is very welcome!

Hi HN!

I'm Ilyas - a web dev.

In this short post I would like to share my mini tool on getting prepared for any dev interview:

- HR - Tech - Behavioral - Live coding - Algo - etc.

In the last five years through all kinds of interviews and summarized preparation in a bite size checklists to quickly go thru before the interview.

This definitely adds at least extra 5% to confidence.

Checklist is free to use.

In general, "checklist" is proven tool that is used by pilots and doctors. This method helps you to make sure that all necessary steps are checked by you. Unloads your memory.

If interested, check it out here: https://www.99cards.dev/checklists

p.s. again, it's free.

Enjoy! Ilyas

Hey HN! Pivor v1.1 just dropped and I'm pumped to share it with you.

Pivor is a self-hosted CRM for small businesses who want to own their data. No per-seat pricing, no cloud lock-in, no BS.

What's new in v1.1: • Gmail & Outlook integration, two-way email sync, send directly from the CRM • Full REST API, token auth, full CRUD, filtering, pagination • Task reminders, email notifications before deadlines • Role-based access, admin, manager, user with granular permissions • CSV import/export, migrate your data in minutes

Stack: Laravel 12 + Livewire 3 + Tailwind. Runs on SQLite, scales to MySQL/PostgreSQL.

Your customers, your servers, your data. AGPL-3.0.

GitHub: https://github.com/Lexaro-Software/pivor

What would make Pivor useful for your team? I'm listening!

Hi HN,

I built an open-source sync engine that brings "Local-First" capabilities to Go web applications.

The Problem: Most offline-first solutions (Firebase, PouchDB) force you into the JS ecosystem. If you are writing a Go backend, you often have to re-implement sync logic or settle for simple REST APIs that break when the user goes offline.

The Solution: GoSync runs the exact same Go code in the browser (via WebAssembly) and on the server. - Client: Go compiled to WASM, persisting to IndexedDB (via a small JS bridge). - Server: Go with SQLite or Postgres, persisting to disk. - Protocol: Merkle Trees to detect diffs, and WebSockets to sync them.

If the server dies or the user goes offline, the client keeps working. When connectivity returns, it heals the state automatically.

I'd love feedback on the Merkle Tree implementation and the WASM/JS bridge architecture.