2026년 1월 3일의 Show HN

This is definitely out of my comfort zone. I've never programmed DSP before. But I was able to use Claude code and have it help me build this using CMajor.

I just wanted to show you guys because I'm super proud of it. It's a 100% faithful recreation based off of the schematics, patents, and ROMs that were found online.

So please watch the video and tell me what you think

https://youtu.be/auOlZXI1VxA

The reason why I think this is relevant is because I've been a programmer for 25 years and AI scares the shit out of me.

I'm not a programmer anymore. I'm something else now. I don't know what it is but it's multi-disciplinary, and it doesn't involve writing code myself--for better or worse!

Thanks!

I’m building Corviont, a self-hosted offline maps appliance (tiles + routing + search) for edge/on-prem devices.

Hosted demo (no install): https://demo.corviont.com/

Self-host (Docker Compose repo): https://github.com/corviont/monaco-demo

Docs: https://www.corviont.com/docs

What’s inside:

  - Vector tiles served locally (PMTiles)
  - Routing served locally (Valhalla)
  - Offline geocoding/search + reverse (SQLite Nominatim-based index)
  - MapLibre UI wired to the local endpoints

Next (if people need it): a signed on-device updater for regional datasets (verify → atomic swap → reload).

I’d love feedback: where offline maps/routing/search matters for you, and what constraints bite (hardware, fleet size, update windows, regions, deployment style).

I used Claude Code for most of the setup. I had a blast.

It's running termux, andronix, nginx, cloudflared and even a prometheus node exporter.

Here's the site:

https://walmartphone.stetsonblake.com/

Few noteworthy YC startups which have had huge impact in YC ecosystem

Airbnb - 83 YC startups spawned

Stripe - 67 YC startups spawned

Dropbox - 50 YC startups spawned

Justin.tv/Twitch - 47 YC startups spawned

More recently founded YC startups which have spawned a lot more YC startups

Rappi - 21 YC startups spawned

Brex - 20 YC startups spawned

Scale AI - 19 YC startups spawned

I built fp-pack, a small TypeScript functional utility library focused on pipe-first composition.

The goal is to keep pipelines simple and readable, while still supporting early exits and side effects — without introducing monads like Option or Either.

Most code uses plain pipe/pipeAsync. For the few cases that need early termination, fp-pack provides a SideEffect-based pipeline that short-circuits safely.

I also wrote an “AI agent skills” document to help LLMs generate consistent fp-pack-style code.

Feedback, criticism, or questions are very welcome.

What it does: - Full SMTP server (inbound/outbound, DKIM signing, SPF/DMARC checking) - IMAP with IDLE support - CalDAV/CardDAV (replace Google Calendar/Contacts) - Web admin panel with Prometheus metrics - Greylisting for spam prevention - Auto-discovery (mail clients configure themselves) - Audit logging for compliance

What it doesn't do: - Webmail (use Roundcube, etc.) - ML-based spam filtering (greylisting + basic heuristics only) - Clustering/HA

  Hey HN,

  I built Underpriced AI to solve a problem I had as a part-time reseller: standing in a thrift store trying to figure out if something is worth buying.

  How it works:
  - Snap a photo of any item
  - AI identifies the brand, model, maker, era, etc.
  - Pulls recent sold prices from eBay and other marketplaces
  - Gives you an instant valuation with confidence score

  You can also generate SEO-optimized eBay listings and publish directly from the app.

  Tech stack: Next.js, Claude API for vision/analysis, eBay API for market research and listing.

  The "Quick Scan" feature is designed for mobile – get a price check in seconds while you're out sourcing.

  Free tier available. Would love feedback from anyone in the reselling space or who's worked on similar pricing/valuation problems.

  https://underpricedai.com

I built HackLens, a modern Android/IOS app for browsing Hacker News with a cleaner and smoother reading experience.

Why I built it I love Hacker News, but wanted:

a cleaner reading experience

better topic discovery

modern UI

lightweight performance

So I built HackLens.

Key features

1. Clean, modern UI inspired by minimal reading apps

2. Fast browsing of Hacker News stories

3. AI-powered summaries to quickly grasp key points

4. Read full articles directly from the source

5. Trending stories (last 1h, 6h, or 24h)

6. Built-in search to find stories and topics

7. Topic discovery based on your interests and Get notified

8. Light & dark mode with adjustable font size

9. Bookmark stories to read later

10. Cross-device sync for bookmarks, topics, and preferences

Download Google Play: https://play.google.com/store/apps/details?id=com.berranova....

App Store: https://apps.apple.com/fr/app/hacklens-hacker-news-reader/id...

I’d love your feedback If you have suggestions, find bugs, or want features, I’d genuinely appreciate it — I built HackLens to learn and improve.

Thanks for checking it out!

So I made this — a map where you drop a pin and see who else is around.

Filter by digital nomads, freelancers, remote workers, retirees. See if they just arrived or have been there for years.

Spot someone interesting? Send a message.

No signup. No feed. No tracking. No algorithm. Just a map.

More like exploring than scrolling.

Built with Next.js, Supabase, and Leaflet.

Features: - 100% self-hosted, runs on your machine - Multi-session support with Telegram topics - Voice messages (transcribed with Whisper) - Image attachments for Claude to analyze - tmux integration for session persistence

Built with Go. Would love feedback!

Jetbase has: - strict validation to detect altered or removed migration files after they’ve been applied (prevents drift, fails fast) - database locking so multiple migration processes can’t run at the same time - full rollback support - ascending version numbers enforced directly in filenames so migration history is obvious - uses raw sql instead of ORMs

The main Python tool is Alembic, but it’s mainly used with an ORM and doesn’t include things like validation checks. So I built Jetbase to add the features I was looking for.

Some other things I ran into:

- tools with more validation checks than Alembic were usually Java-based, not Python - some tools gate rollback support behind paid tiers - wanted a way to easily see migrations history

Moved off ORMs to raw SQL, which made Alembic’s ORM integration not necessary. Why I moved off: - explored queries directly in DB UI tools (DBeaver, Snowflake) and didn’t want to rewrite them in ORM syntax - ORMs didn’t make sense for Python data pipelines (S3 → Snowflake → Postgres) - raw SQL was more efficient for things beyond basic CRUD - shared a database with a sister team and didn’t want to create extra ORM models in API to query their stuff

Repo (with a quick start guide): https://github.com/jetbase-hq/jetbase

It currently supports Postgres and SQLite (planning to add more databases)

Would love to hear any feedback!

Sections .rodata та .dynstr contain only names. That's why I created DYNUM scanner numeric constants, enough digging in Hex!

How it works: 1. Scans files as raw bytes, interpreting them as every possible numeric type (int8, int32, float, double, both endianness) 2. Filters out noise: aligned addresses, reasonable values, no NaN/Inf 3. Optionally integrates with nm/readelf to show symbol names 4. Architecture-aware (x86, x64, ARMv7, ARM64) 5. Follows Unix philosophy: text output, pipes friendly, single purpose

GitHub: https://github.com/Ferki-git-creator/dynum

It’s not just a script; it’s the architectural vision behind Ultra Meta. Check the HAPPY_NEW_YEAR.md file for the source

This introduces a specific failure mode: AI can generate text that constitutes an irreversible business commitment (refunds, credits, billing changes, contractual promises).

Once emitted, the commitment exists. Detection after delivery is irrelevant.

This project implements a hard authority boundary.

Model -------- AI systems propose messages. They do not decide whether those messages are allowed to commit the company.

A gateway enforces that decision.

AI drafts message ↓ Authority Gateway ↓ Send | Block → Approval

Behavior --------- For each outbound message:

Inspect text for commitment signals

Classify outcome as reversible or irreversible

If reversible → allow

If irreversible → block and require explicit approval

Log decision and evidence

No attempt is made to assess advice quality, intent, or correctness. Only enforceability is considered.

API surface ------------ /v1/messages/send Enforces authority on outbound messages

/v1/support/messages/decide Decision-only endpoint for support systems Returns structured reasons and a safe fallback reply

Properties ---------- Deterministic enforcement

Idempotent execution

Explicit approval for irreversible actions

No reliance on prompt discipline or training hygiene

No agent autonomy

This is a sandbox implementation to test whether a narrow authority layer is useful in practice.

Feedback welcome from teams already routing AI-generated messages into real customer workflows.

I’m Fredrik, the founder of Simuletic. I’m an engineer working in Computer Vision, and I kept hitting a wall with object detection models in security scenarios: they are terrible at detecting "edge cases" that are rare or dangerous in the real world.

Some of the most difficult problems I have faced is "weapon detection" and "lying / falling detection".

To train an AI to detect someone falling or lying injured, you need thousands of images. But getting real data is an ethical nightmare—you can't ask elderly people to fall down stairs, and you can't use real accident footage due to privacy.

The current industry solution is using actors. But actors instinctively protect themselves when falling; they don't capture the chaotic, dead-weight reality of a true medical incident. Models trained on actors fail on real victims.

The Solution: A Rendering Pipeline Instead of scraping the web for bad data, I built a rendering pipeline to generate physically accurate and highly realistic synthetic data specifically for CCTV angles.

By using a AI generation local pipeline (no data leaves my own server) I can simulate any scenario with high realism, unlike 3d simulation tools... including bounding boxes.

The pipeline automatically generates perfectly annotated ground truth (bounding boxes and segmentation masks) for every frame, solving the massive headache of manual labeling.

I’ve released the first batch on Kaggle for different scenarios. It’s designed specifically to bridge the "sim-to-real" gap for overhead cameras.

Kaggle Link: https://www.kaggle.com/datasets/simuletic/cctv-incident-data...

Specs: CCTV resolution and noise profiles, varied lighting (indoor/outdoor), and high-angle perspectives.

Format: Annotations are YOLO-ready out of the box.

What I want from HN: I know many of you work with YOLO and other CNNs. I’d love for you to throw this dataset into your training mix and see if it improves recall on "lying down" classes in real-world tests.

I’m here to answer questions about the rendering pipeline, the domain randomization techniques used, or the challenges of sim-to-real transfer.

Thanks, Fredrik

Adding a goal:

/d 50 pushups

Chain them:

/d 50 pushups /w 3 gym sessions /m finish project /y learn piano

Updating progress:

Create an alias with /alias p pushups, then just type 25 p to add 25. Three characters.

Review your week with /review 7d. Rename goals, change targets, convert between quadrants—all through commands.

Each quadrant auto-resets at the right interval (daily at midnight, weekly on Monday, etc). You don't manage anything.

Why I built it this way: I kept bouncing between productivity apps looking for something faster. Nothing stuck because they all wanted me to click through menus and organise things. I just wanted to type and move on.

So I made something deliberately constrained. One input. Four quadrants. No settings screen. No integrations. The lack of features is the point.

Curious what the HN crowd thinks—especially if the command syntax feels intuitive or too obscure. Still iterating.

Most AI resume builders give you a block of text to copy paste. I wanted something more integrated, so I built a split-pane interface where the PDF updates live as you chat.

Key Features:

Conversational Editing: You can say "Add my new role at XYZ" or "Shorten my summary to 3 lines," and it handles the formatting and insertion live.

Visual Diffing: Any change the AI makes is highlighted in yellow so you can verify the edits instantly.

JD-Specific Optimization: You can paste a Job Description and the AI re-aligns your bullet points for ATS keyword relevance.

Version Control: It maintains a version history, allowing you to roll back specific changes if the AI hallucinates or misses the mark.

Evaluate Suite: It provides a real-time ATS/Impact score and catches technical errors like malformed LinkedIn/GitHub URLs.

I built this because I found the feedback loop between "generating text" and "fixing PDF margins" too slow. I'm keeping this free for now to gather feedback on the UX and the accuracy of the ATS scoring.

Website: https://sakshatkarai.com Direct Link: https://app.sakshatkarai.com

I'd love to hear your thoughts on the "chat-to-update" workflow. Does this solve a real pain point for you?

What it does:

- Parses Svelte files with a custom Rust parser - Transforms them to TSX in parallel using Rayon - Runs type-checking via Microsoft's tsgo (the native Go port of TypeScript) - Maps errors back to original .svelte locations via source maps

Why it's fast:

The official svelte-check uses TypeScript's Language Service API optimized for IDEs with persistent connections. Great for autocomplete but slow for batch CLI checks.

svelte-check-rs writes real TSX files to disk and runs tsgo as a standalone compiler. This enables incremental builds with persistent .tsbuildinfo, so subsequent runs only re-check changed files.

Benchmarks on a 650-file SvelteKit monorepo (M4 Max):

  Cold: 17.5s vs 39.6s (2.3x faster)
  Warm: 1.3s vs 39.4s (30x faster)
  Iterative: 2.5s vs 39.8s (16x faster)

I built this in ~2 days using Claude Code (Opus 4.5) and Codex CLI (GPT-5.2 xhigh). The entire Svelte parser, TSX transformer, diagnostics engine, and CLI were written entirely by AI. I focused on architecture decisions and testing against real codebases while the models handled the implementation.

My motivation was actually to make AI coding agents more effective. When agents write code, they need to verify it works, and waiting 40 seconds for type-checking kills the feedback loop. With 1-2 second checks, agents can iterate much faster and catch their own mistakes immediately on our large and growing production SvelteKit codebase.

Website: https://svelte-check-rs.vercel.app/

A lot of other tools are more CLI-oriented. I have tried to compile an honest comparison here: https://github.com/chmouel/lazyworktree/blob/main/COMPARAISO...

Some of the code and documentation was written with an LLM if that bothers anyone :)

All data is e2e encrypted before it leaves your device, the share url contains the decryption key.

Self-host on Cloudflare workers if you prefer

This repo contains a proof-of-concept experiment ("The Lazarus Effect"): 1. I train a network until convergence. 2. I destabilize it (catastrophic forgetting). 3. I restore accuracy NOT by retraining on data, but by applying a stability operator to the recursive dynamics.

It suggests that memory can be treated as a stability parameter rather than just stored information. I'd love your feedback on the code and the approach.

It's a menu bar app that lets you define a "focus workspace" - a set of apps that should be visible. Press ⌘⇧P and everything else hides instantly.

Features: - Multi-monitor: assign apps to specific screens - Per-app maximize toggle - Native Swift, ~2MB - MIT licensed

Website: https://gabrycina.github.io/FocusMode/ GitHub: https://github.com/gabrycina/FocusMode

Happy to answer questions about the implementation.

The model scrapes historical data from Basketball Reference and uses Exponentially Weighted Moving Averages (EWMA) to capture recent team momentum and form. It's powered by XGBoost and achieves roughly 70% prediction accuracy.

The web interface (built with NiceGUI) lets you visualize upcoming matchups, see key statistical differences between teams, and get real-time predictions.

All data is free and public, and it runs locally across all platforms. The model training notebook is included if you want to retrain or experiment with the features.

Would love feedback on the approach or suggestions for improving accuracy!

Live demo: https://deepshot.onrender.com

- Vanilla PHP, zero dependencies - 14 loci, 310+ ALBS-compliant phenotypes dynamically resolved - Cartesian product across all loci computed in milliseconds - Sex-linked inheritance (ZZ/ZW avian system) with proper hemizygosity - Wright's inbreeding coefficient with 6-generation pedigree traversal - Near-Bayesian inference engine: reverse-estimates parental genotypes from offspring phenotypes

No frameworks, no libraries. Just math and arrays.

Live demo: http://kanarazu-project.com/gene-forge/Rosy-faced-Lovebird/?...

I built todotree to solve a problem I kept running into: TODO lists scale poorly once tasks start depending on each other.

Instead of a flat list or grep output, todotree treats TODOs as nodes in a dependency tree (inspired by Makefiles structure and Markdown format). This makes it easier to see what’s actionable, what’s blocked, and how tasks relate.

Key features: - Tree-based visualization of TODOs and their dependencies

- Automatically highlights actionable tasks (red)

- Supports completed (~ / ~~) tasks, shown in blue

- Multiple output formats: terminal, HTML, Markdown, JSON

- Simple Markdown-based input format

- Fast, standalone CLI tool (written in Rust)

I primarily use it to track technical debt and project planning in Markdown files, but it can also be used to visualize TODOs in any structured task list.

Demo + examples are in the repo: https://github.com/daimh/todotree

I’d really appreciate feedback:

- Is the dependency-tree model useful for TODOs?

- Are there similar tools people prefer?

- What would make this more useful in real projects?

Thanks!

I’ve been quietly building an experiment called Society Speaks to explore a question that’s bothered me for a long time:

Can we measure public opinion without flattening it into polls, comments, or outrage?

Instead of comments or demographics, the system uses: • clear statements • simple voting (agree / disagree / unsure) • optional short explanations

People aren’t grouped by who they say they are, but by how they actually respond. Using ML techniques inspired by Pol.is, this reveals natural opinion clusters, areas of genuine consensus, ideas that bridge different groups, and honest fault lines where agreement doesn’t yet exist.

There’s a small daily entry point (inspired by Wordle): one question per day, ~2 minutes to answer, insight revealed only after you respond. Over time, this creates a longitudinal, more nuanced view of public opinion than polls or comment sections usually provide.

We also take curated news articles and podcasts and turn them into structured prompts for deliberation, rather than reactive debate.

This isn’t a finished product and I’m not claiming it “solves” democracy. I’m mostly interested in whether this approach is: • methodologically sound • useful compared to traditional polling or forums • flawed in ways I haven’t spotted

If you’re curious, today’s question is here: https://societyspeaks.io/daily

I’d genuinely value critique, especially from people who’ve worked on polling, deliberative democracy, or large-scale opinion systems.

TikTask started as a message scheduler, but I kept running into the same reality: people don’t just want “send later”, they want reliable follow-up routines for business and for daily life.

What TikTask is: a message scheduler + on-device automation app for Android. You schedule messages and routines, and the execution happens locally on your phone, not on my servers.

What “on-device automation” means (and why it matters):

On-device (TikTask): your phone executes the scheduled actions at the right time. No cloud worker sending messages, and no need to wire up official APIs for common personal workflows.

Official APIs: great for businesses at scale, but usually require a backend, verification/compliance, templates, and per-message costs, and they don’t fit many “personal phone” workflows.

Cloud automations: powerful, but your automation and often your content lives off-device, which can add cost and privacy considerations.

With on-device automation, the model is simple: private by design (your data stays on your phone) and cheap to operate (no per-message infrastructure), which is especially useful when you’re growing a small business and want to automate follow-ups without building a backend.

Use cases I built for:

Business: lead follow-ups, client reminders, appointment nudges, promo announcements

Daily life: birthdays, family reminders, recurring check-ins, routines you don’t want to forget

The hard part (and the part I’m proud of): reliability. Android background limits and OEM battery managers can silently kill automations. A lot of the work went into a “System Monitor” style checklist that helps users enable the right settings so schedules actually run.

I’d love feedback from HN:

Does this positioning make sense, or does it confuse people (“message scheduler” vs “automation”)?

If you’ve built anything that depends on Android background execution, what reliability traps did you hit?

What would you want to see to trust a scheduler like this for business follow-ups?

If anyone wants to test premium/locked features and give blunt feedback, reply or DM and I’ll share a promo code.