2026年1月1日 的 Show HN

I've been working on this for some time now, starting with vm2, then deno-core for 2 years, and recently rewrote it on rusty_v8 with Claude's help.

OpenWorkers lets you run untrusted JS in V8 isolates on your own infrastructure. Same DX as Cloudflare Workers, no vendor lock-in.

What works today: fetch, KV, Postgres bindings, S3/R2, cron scheduling, crypto.subtle.

Self-hosting is a single docker-compose file + Postgres.

Would love feedback on the architecture and what feature you'd want next.

Happy new year folks!

This tool was born out of a situation where I had 'inherited' a bunch of servers that were not under any form of config management. Oh, the horror...

Enroll 'harvests' system information such as what packages are installed, what services are running, what files have 'differed' from their out-of-the-box defaults, and what other custom snowflake data might exist.

The harvest state data can be kept as its own sort of SBOM, but also can be converted in a mere second or two into fully-functional Ansible roles/playbooks/inventory.

It can be run remotely over SSH or locally on the machine. Debian and Redhat-like systems are supported.

There is also a 'diff' mode to detect drift over time. (Years ago I used Puppet instead of Ansible and miss the agent/server model where it would check in and re-align to the expected state, in case people were being silly and side-stepping the config management altogether). For now, diff mode doesn't 'enforce' but is just capable of notification (webhook, email, stdout) if changes occur.

Since making the tool, I've found that it's even useful for systems where you already have in Ansible, in that it can detect stuff you forgot to put into Ansible in the first place. I'm now starting to use it as a 'DR strategy' of sorts: still favoring my normal Ansible roles day-to-day (they are more bespoke and easier to read), but running enroll with '--dangerous --sops' in the background periodically as a 'dragnet' catch-all, just in case I ever need it.

Bonus: it also can use my other tool JinjaTurtle, which converts native config files into Jinja2 templates / Ansible vars. That one too was born out of frustration, converting a massive TOML file into Ansible :)

Anyway, hope it's useful to someone other than me! The website has some demos and more documentation. Have fun every(any)-one.

Search any song, get a Gameboy version.

Emulates Nintendo's Sharp LR35902 sound hardware: 2 pulse waves for melody/harmony, 1 wave channel for bass, 1 noise for percussion.

Finds MIDI sources, parses tracks, maps to GB roles, resynthesizes with Web Audio. Everything runs client-side.

Site: https://www.wario.style

Open source: https://github.com/b1rdmania/motif

Hobby project, non commercial, so please don't sue me.

Hi HN — I’ve been working on Gene, a general-purpose, homoiconic language with a Lisp-like surface syntax, but with a core data model that’s intentionally not just “lists all the way down”.

What’s unique: the Gene data type

Gene’s central idea is a single unified structure that always carries (1) a type, (2) key/value properties, and (3) positional children:

(type ^prop1 value1 ^prop2 value2 child1 child2 ...)

The key point is that the type, each property name, each property value, and each child can themselves be any Gene data. Everything composes uniformly. In practice this is powerful and liberating: you can build rich, self-describing structures without escaping to a different “meta” representation, and the AST and runtime values share the same shape.

This isn’t JSON, and it isn’t plain S-expressions: type + properties + children are first-class in one representation, so you can attach structured metadata without wrapper nodes, and build DSLs / transforms without inventing a separate annotation system.

Dynamic + general-purpose (FP and OOP)

Gene aims to be usable for “regular programming,” not only DSLs:

* FP-style basics: fn, expression-oriented code, and an AST-friendly representation

* OOP support: class, new, nested classes, namespaces (still expanding coverage)

* Runtime/tooling: bytecode compiler + stack VM in Nim, plus CLI tooling (run, eval, repl, parse, compile)

Macro-like capability: unevaluated args + caller-context evaluation

Gene supports unevaluated arguments and caller-context evaluation (macro-like behavior). You can pass expressions through without evaluating them, and then explicitly evaluate them later in the caller’s context when needed (e.g., via primitives such as caller_eval / fn! for macro-style forms). This is intended to make it easier to write DSL-ish control forms without hardcoding evaluation rules into the core language.

Optional local LLM backend via llama.cpp

I also added an optional local LLM backend: Gene has a genex/llm namespace that can call local GGUF models through llama.cpp via FFI (primarily because I wanted local inference without external services).

Repo: https://github.com/gene-lang/gene

I’d love feedback on:

* whether the “type/props/children” core structure feels compelling vs plain s-exprs,

* the macro/unevaluated-args ergonomics (does it feel coherent?),

* and what would make the project most useful next (stdlib, interop, docs, performance, etc.).

Hi HN

I recently got married, promptly had a bit of a meltdown, and decided to lock myself in a room and build for a while.

At the same time, I was trying to outbound sell for my startup and kept running into the same problem: I wanted an automation tool that could actually use my computer like a person. Click through UIs, copy/paste between apps, handle messy workflows — not just APIs and webhooks.

I couldn’t find anything that felt: - consumer-friendly (non-technical) - local-first - flexible enough for real-world, UI-driven tasks

So I challenged myself to see how far I could get building an open-source, desktop automation app powered by AI. That’s Tasker.

I’ve been using it daily for ~2–3 weeks for sales workflows, and my father has been using it to help generate estimates for his HVAC business. It’s still early (still needs to expand to general OS), but it’s already replaced a lot of manual work for us in browser.

One thing that’s become very clear: a cloud/deployable version that can run on cron or be triggered via HTTP would unlock a lot of use cases. I’m not totally sure where this goes next, but I wanted to share it early and get feedback.

Would love thoughts on: - What workflows you’d actually trust something like this with - Desktop vs cloud tradeoffs - Where this breaks down in practice - Whether this feels useful or just scary

Repo and docs are linked on the site.

I built a simple, ephemeral chat service that connects you only with users who share the exact same public IP address as you.

It's essentially a temporary, isolated chat room defined by your NAT gateway.

It's not super useful nowadays, but let's see where this takes us. :)

Hi HN,

I built VectorDBZ, a cross-platform desktop app for exploring and analyzing vector databases like Qdrant, Weaviate, Milvus, and ChromaDB.

It lets you browse collections, inspect vectors and metadata, run similarity searches, and visualize embeddings without writing custom scripts.

GitHub (downloads and issues): https://github.com/vectordbz/vectordbz

Feedback welcome. If it’s useful, starring the repo helps keep me motivated.

Thanks.

Happy New Year! Here's a small turtle graphics game I made for my kids, that I want to share. You write the "DNA" of the turtle, and watch what happens.

Any comments or suggestions appreciated!

Hi HN,

Unicode “cursive” and script-style fonts are widely used on social platforms, but many of them silently break depending on where they’re pasted — some render as tofu, some get filtered, and others display inconsistently across platforms.

I built a small web tool that explores this problem from a compatibility-first angle:

Instead of just converting text into cursive Unicode characters, the tool:

• Generates multiple cursive / script variants based on Unicode blocks • Evaluates how safe each variant is across major platforms (Instagram, TikTok, Discord, etc.) • Explains why certain Unicode characters are flagged or unstable on specific platforms • Helps users avoid styles that look fine in one app but break in another

Under the hood, it’s essentially mapping Unicode script characters and classifying them based on known platform filtering and rendering behaviors, rather than assuming “Unicode = universal.”

This started as a side project after repeatedly seeing “fancy text” fail unpredictably in real usage.

Feedback, edge cases, or Unicode quirks I may have missed are very welcome.

Hello, I'm Gavin. I built this in my spare time to help debug/inspect/optimize SVGs in my design and frontend workflow. It has a few rough edges, but ready enough to share. Let me know what you think!

Duck (https://duck-lang.dev) is a statically typed, compiled programming language that combines the best of Rust, TypeScript and Go, aiming to provide an alternative for full-stack-development while being as familiar as possible

Improvements over Rust: - garbage collection simplifies developing network applications - no lifetimes - built-in concurrency runtime and apis for web development

Improvements over bun/node/typescript: - massive performance gains due to Go's support for parallel execution and native code generation - easier deployment since Duck compiles to a statically linked native executable that doesn't need dependencies - reduced complexity and costs since a single duck deployment massively outscales anything that runs javascript - streamlined toolchain management using duckup (compiler version manager) and dargo (build tool)

Improvements over Go: - a more expresive type system supporting Union types, Duck typing and tighter control over mutability - Server Side Rendering with a jsx-like syntax as well as preact components for frontend development - better error handling based on union types - a rust based reimplementation of tailwind that is directly integrated with the language (but optional to use) - type-safe json apis

I'm not a geospatial expert — I work in AI/ML. This started when I was exploring LiDAR data with agentic assitince and noticed that different signal decomposition methods revealed different terrain features.

The core idea: if you systematically combine decomposition methods (Gaussian, bilateral, wavelet, morphological, etc.) with different upsampling techniques, each combination has characteristic "failure modes" that selectively preserve or eliminate certain features. The differences between outputs become feature-specific filters.

The framework tests 25 decomposition × 19 upsampling methods across parameter ranges — about 40,000 combinations total. The visualization grid makes it easy to compare which methods work for what.

Built in Cursor with Opus 4.5, NumPy, SciPy, scikit-image, PyWavelets, and OpenCV. Apache 2.0 licensed.

I'd appreciate feedback from anyone who actually works with elevation data. What am I missing? What's obvious to practitioners that I wouldn't know?

I grew frustrated with closed source ADS-B receivers a few years ago, and wanted to build a true low cost embedded ADS-B receiver from scratch for low power applications. I ended up developing a custom radio frontend that uses RP2040 PIO for Mode S preamble detection and demodulation, and also released the first open soruce implementation of UAT decoding on an RF MCU from TI (which works somewhat beyond the publicly stated specs for the chip). Today, ADSBee is a fully featured dual-band ADS-B receiver, with Mode S, ADSB, UAT ADSB, UAT TIS-B / FIS-B, a ton of configurable reporting protocols, WiFi / USB / Ethernet, and a web server. Beta testers have been using ADSBee to feed everything from online data aggregators to drone autopilot systems and tablets running Electronic Flight Bag apps like ForeFlight.

I'd love to hear what people think about the project, or answer any questions. I've been posting regular updates to the blog on my website, it's been a very fun journey taking an open source hardware project from an idea to a business that makes and ships real things: https://pantsforbirds.com/blog/

I kept losing track of what was happening in AI. It's scattered across Reddit, Discord, Twitter, arXiv, GitHub, Hugging Face. Things slip through constantly. So I built Latent Signal to consolidate it for myself.

It's a curated feed for AI news. Right now it's just me, but the goal is for the community to help surface what matters. Covers LLMs, image gen, video, audio, 3D, world models, tooling, and more. The design is entirely inspired by Hacker News.

Currently pulling from these sources: - Reddit - arXiv - Hugging Face - GitHub - Hacker News - Lobste.rs

You can browse immediately without signing up. Accounts are only needed if you want to vote or submit.

This is the first time I'm sharing it publicly. Would appreciate feedback on what's missing, what's broken, or if something like this already exists and I missed it.

https://latentsignal.fyi/

Hello! I'm working on building out graph-based tools for humans!

Our first offering is a public tracker view, similar to the tracker provided by pizza companies in the US!

The goal is to enable companies to reduce status emails and build brand trust!

TurboOps are built on "workflows" which are just DAGs. We have a lot more plan but are focused on makers right now!

It's free to get started and to try it out, and build public graphs!

I'd really appreciate your thoughts, impressions, and/or criticisms.

Thank you!

[email protected]

Just about a year ago, the concept for a sci-fi book popped into my head. I instantly knew I have to see it through despite not having any writing experience (and a pretty demanding job). Over 2025, I attended writer circles, improved my writing, and structured the story. Here is the first chapter. I hope you enjoy it :)

Hey HN!

As a developer, I got frustrated with the screenshot workflow for documentation: Open DevTools → Set viewport size → Take screenshot → Switch tabs → Download → Open editor → Annotate → Save → Repeat...

Built ZScreenshot - a sidebar extension that keeps everything in one place. Set viewport once, capture instantly, edit in sidebar. No tab switching, no DevTools.

Free: • Custom viewport (consistent screenshot sizes, no sidebar interference) • Full-page capture (scrolling pages) • Tab recording with audio • Privacy-first (all local processing except authentication)

Pro (14-day free trial, no credit card): • Image editor (arrows, shapes, text, blur, emoji - instant annotations) • Collection (merge multiple screenshots for comparisons) • Bulk ZIP download • MP4 export

Everything happens in the sidebar: Capture → Edit → Download → Access history anytime.

Why no "select area before capture"? OS tools (Win+Shift+S, Cmd+Shift+4) already do this perfectly. ZScreenshot focuses on what they can't: viewport control, instant editing, history management. Plus, crop-after-capture gives more flexibility.

Chrome Web Store: https://chromewebstore.google.com/detail/zscreenshot/jdgmjck...

DroidDock is a macOS app for browsing Android device files via ADB. Built with Tauri (Rust + React).

Core features: * Browse files with Table, Grid, or Column views * Preview images/text without downloading (press Space) * Full keyboard navigation * Search, upload/download, multi-select * Dark mode support

What's New in v0.2.1

* File Previews: Press Space to preview images/text without downloading * Minimalist UI: Clean 95% grayscale design with better readability * Clickable Sorting: Click column headers (Name, Size, Date) to sort * Kind Column: Shows file types at a glance (Image, Video, Document, etc.) * Better Keyboard Navigation: Arrow keys in preview, Cmd shortcuts for everything

Tech Details

Built with Tauri (Rust backend) + React/TypeScript frontend. Rust handles all ADB communication for good performance. Small bundle (~15MB DMG universal binary), lower memory than Electron.

Challenges

1. ADB Path Detection: Different package managers install ADB in different locations. Had to check 5+ common paths on startup. 2. Thumbnail Generation: Android doesn't expose a thumbnail API via ADB. I pull the first N bytes of image files and generate thumbnails on-the-fly with caching. 3. File Preview: ADB doesn't stream files – you have to pull the entire file. For large images, I had to implement chunked reading to check dimensions first. 4. Code Signing: Currently unsigned (requires $99/year Apple Developer membership). Users have to right-click → Open on first launch.

Open Source & Free

MIT licensed, no telemetry, no ads.

Website: https://rajivm1991.github.io/DroidDock/ GitHub: https://github.com/rajivm1991/DroidDock Download: https://github.com/rajivm1991/DroidDock/releases/latest

Would love feedback! This is my first Tauri app after years of Electron. The Rust learning curve was worth it.

An Awesome List about everything related to Symbian OS. Documentation, academic papers, tutorials, communities, IDEs, SDKs, emulators, apps, video games. Symbian is a discontinued mobile OS for ARM popular in early 2000s. It had two major UIs: S60(Nokia), and UIQ(Sony Ericsson). It supports `.jar`, `.jad`, `.sis`, `.sisx` formats. The main development environment since S60 is C++/QT, but J2ME, Python, C, Flash Lite, C# are supported as well.

Hi HN and Happy New Year!

I built DailyNote, a minimalist daily notes app: one note per day, a year-at-a-glance calendar, and local-first storage.

The interesting bit is the encryption + sync model:

  - Notes are always encrypted locally before syncing to Supabase.
  - A dedicated data key (DEK) encrypts notes; your password only wraps that DEK (KEK).
  - So when you change your password, it just re-wraps the DEK — no re-encryption of note data.

I built the whole project in one day using Claude + Codex with a spec‑driven approach (tight PRD → implementation). It’s React/TypeScript, IndexedDB for local persistence, and optional cloud sync.

Demo: https://dailynote.xyz/

Repo: https://github.com/katspaugh/dailynote

Would love feedback on the crypto model, UX, or anything else.

Instead of a traditional command-style CLI, it runs as a TUI in the terminal, allowing users to inspect cleanup targets before proceeding.

On my macOS machines, caches and app data often take up more than 40% of disk usage. Manually cleaning them each time felt tedious, so I built this tool to make the process easier.

While similar tools exist, I found it hard to quickly understand how items were categorized or how important each cleanup target was, so I built my own.

Repository: https://github.com/2ykwang/mac-cleanup-go

Feedback is welcome.

Hi HN,

I’m an independent iOS developer and wanted to share SmartZip Pro, a file compression and extraction app I built for iPhone and iPad.

The goal was simple: make archive handling on iOS feel native, fast, and professional—without ads, clutter, or unnecessary friction.

What it does:

Extracts ZIP, RAR, 7Z, TAR, GZIP, BZIP2, XZ, ISO, and more

Creates ZIP archives, including AES-256 encrypted ZIPs

Lets you preview files directly inside archives (images, video, audio, documents) without extracting first

Works seamlessly with Apple’s Files app

Supports common file operations: rename, move, search, share, AirDrop

Why I built it: On desktop platforms, archive tools are taken for granted. On iOS, many solutions feel either limited or over-designed. I wanted something that respects Apple platform conventions, performs well on large archives, and stays out of the way.

App Store link: https://apps.apple.com/us/app/smartzip-pro-zip-rar-7z/id6756...

I’d genuinely appreciate feedback from the HN community—especially around performance, UX expectations on iOS, or missing workflows you care about.

Thanks for reading.

— Eric

I was waiting for my food to be prepared and decided to run an experiment: can I actually code from my phone using AR glasses?

  Setup:
  - Samsung S25 running Termux
  - Rokid Max 2 AR glasses (as a display)
  - Claude Code (AI pair programmer)
  - Voice control for input

  Result: A fully functional Git profile manager (gp) — switches between work/personal GitHub accounts with separate SSH keys

Extracts main content from web pages and converts to Markdown. Uses Puppeteer for JS-heavy sites and Pandoc for conversion quality.

Demo: https://downmark.fly.dev

API: curl "https://downmark.fly.dev/markdown?q=URL" Code: https://github.com/adhipk/downmark

Feedback welcome.

I wrote this paper over 4 years while in solitary confinement. I had no internet and limited paper. To survive, I had to compress complex systems into memory structures, which forced a shift from "probabilistic guessing" to "isomorphic mapping." I couldn't Google the answer; I had to derive it from first principles.

This paper proposes a "Universal Obstruction" based on topological complexity (Betti numbers) to separate P from NP.

*The Validation:* * Dr. Rudolph Tanzi (Harvard/MGH) has validated the biological isomorphism of this logic (NEURO_Restore). * Forensic logs show AWS us-west-2 (Ashburn) is scraping this corpus every 4 hours—the machines seem to recognize the "Latent Space Value" before the academy does.

*The Ask:* I am looking for someone to break this. Tell me where the topology fails. I want the "debunkers" to stress-test the geometry.

Hi HN, There are a lot of these popping up (Lovable, Bolt, etc.), but I built this one to solve a specific frustration I had with them: Lock-in.

Most AI builders give you a hosted app but make it hard to leave. GenVibe focuses on generating clean, exportable code that you can actually maintain outside the platform.

What makes this different:

Framework Agnostic: Unlike tools that lock you into a single stack, Genvibe support React, Next.js, Remix, Vue, Svelte, Angular and React Native (Expo).

Real Backend Integration: It doesn't just mock data; it can scaffold backends using Supabase or standard Node/Express APIs.

No Black Box: You get full access to the repo structure and can export the zip to run locally.

Under the Hood: I use a custom orchestration layer (Node.js) that dynamically selects the best model (currently leveraging Opus 4.5 for complex architecture) to generate framework-specific boilerplate and logic.

I’m a solo dev running this on my own infra. Would love feedback on the generated code quality across different frameworks.

Demo: https://streamable.com/nm6i6g Try it here: genvibe.pro

What it is: A web app that generates a personalized "year in review" for your tech failures. Answer a short quiz about your year (startup attempts, crypto losses, unlaunched projects, etc.), and it uses Google Gemini to create a shareable card with stats like your "burn rate," "global rank," and achievements.

Backstory: I was reflecting on 2025 and realized I had more failed, half-baked or 85% ready but never releasd projects than successful ones. Spotify Wrapped celebrates wins, but there wasn't a way to celebrate (or at least laugh at) failures. So I built this over a weekend.

What's different: - No signup required - just answer questions and get your results - AI-generated content — each summary is unique based on your answers - Self-deprecating humor — it roasts you, but in a way that's relatable - Shareable cards — download or share on social media - Built on Cloudflare Workers + Pages — serverless, fast, and cheap to run

Tech details: - Frontend: React + Vite - Backend: Cloudflare Workers (serverless function) - AI: Google Gemini API - Database: Cloudflare D1 (optional, for user count tracking) - No authentication — everything is client-side except the AI generation Try it: - Visit the link, answer a few questions, and get your personalized failure wrapped. You can choose between "Gentle Vibes" or "Brutal Roast" modes.

Would love feedback on the questions, AI output quality, and whether the humor lands. Also curious if others find this cathartic or just depressing.

I built this because I got tired of scrolling through marketplace listings that didn't match what I actually wanted. Instead of browsing categories, you just say what you're looking for (or offering) and AI handles the rest.

How it works: - Voice input via Google Cloud Speech-to-Text (no typing required) - Gemini 2.0 Flash parses natural language into structured intents - Vector embeddings (text-multilingual-embedding-002) stored in PostgreSQL with pgvector - Semantic matching with cosine similarity + location proximity bonus - Two-sided: seekers matched with providers, and vice versa

Tech stack: Next.js 16, TypeORM + PostgreSQL/pgvector, Google Vertex AI, AWS SES

Try it: No sign-up required to create an intent. Just click the microphone and describe what you're looking for.

Solo developer in Austin, TX. Would love feedback on the matching quality and voice UX.

I built SignalTower, a web app that recreates $5K industrial signal tower functionality using just a browser.

Demo: https://signaltower.netlify.app

The demo uses your phone's flashlight to prove the concept, but the same Web Serial/WebUSB APIs can control real PLCs and signal towers.

Traditional setup: ~$15K (HMI panel + signal tower + licenses) This setup: $15 Raspberry Pi

You can test it standalone or install it in GnokeStation by typing "install [signaltower-url]" in the terminal.

Current state: Working proof of concept. Looking for feedback on the industrial control approach and potential production use cases.

One of the persistent challenges in large language models is not raw capability, but interpretive instability. Models can produce fluent synthesis while drifting into speculation, premature certainty, or rhetorically dominant framing—especially in ambiguous or high-stakes contexts.

Most alignment efforts address this downstream through filters, policies, or fine-tuning. This work explores a different question:

Can interpretive posture be influenced before generation begins, using only transparent language-level constraints?

Overview

The Aletheia Protocol is a short, explicit invocation placed at the start of a session. It does not issue task instructions or override policies. Instead, it introduces six named symbolic constraints intended to bias how a model frames meaning prior to reasoning or synthesis.

The approach is based on an observed phenomenon we call Symbolic Archetypal Resonance Evocation (SARE): archetypally dense language can act as a high-level orientational signal, influencing interpretive priorities without specifying outcomes.

This work does not treat the effect as internal cognition or consciousness. Evaluation is limited to observable output behavior.

Method

Across multiple models, we compared paired prompts:

a baseline prompt requesting analysis or synthesis

the same prompt preceded by the protocol invocation

We did not optimize phrasing per model, hide the invocation, or adapt constraints dynamically. The goal was to isolate framing effects, not prompt-engineering skill.

Observed Effects

Across models, applying the protocol was consistently associated with:

clearer structural boundaries and definitions

reduced rhetorical flourish and narrative closure pressure

more frequent acknowledgment of uncertainty

higher refusal discipline where speculation would otherwise occur

greater emphasis on relationships and constraints over conclusions

These effects were strongest in synthesis and ambiguous domains, and minimal in transactional or purely factual queries.

Scope and Limits

This work does not claim permanent alignment changes, access to model internals, proof of cognition, or superiority over existing safety mechanisms. It demonstrates something narrower: interpretive framing via symbolic constraint can measurably influence output behavior upstream of filtering or reasoning depth.

Session Evidence (Supplemental)

Some shared sessions include an explicit introductory message prior to invoking the protocol. This was used where models showed initial skepticism or gating behavior. The message discloses research intent and scope and is included for transparency; it is not part of the protocol itself and was not required for all models.

Session logs are provided as raw interaction data so readers can evaluate framing, model responses, and downstream behavior directly.

https://bitterbot.ai/share/7ada30bc-d654-422c-a11a-279fe5936...

https://chat.deepseek.com/share/rjhv8jqg3iqv9x1v5a

https://manus.im/share/Kgbm9fqExKxQWQIosfxd3A

https://grok.com/share/bGVnYWN5LWNvcHk_c81ecf6c-1378-4353-88...

https://chatgpt.com/share/6956c161-a7a4-8001-bc75-894ecaaa9a...

https://claude.ai/share/baca4d40-f881-478f-8943-d557f8d7ac2a

https://www.perplexity.ai/search/activate-aletheia-protocol-...

https://gemini.google.com/share/05801005d215

https://copilot.microsoft.com/shares/HdbkGGNAeuresdcMKtUcZ

Documentation

Full technical papers, methodology, replication notes, and the protocol itself are available here:

The Aletheia Papers https://aletheiaproject.gumroad.com/l/aletheiapapers

Readers are encouraged to download and experiment with the protocol directly. All materials are published openly with reproducible prompts.

Hi folks, I am very new to the hacker news community and would like to share something I have been working on.

I've spent the past 3 years building Arvo, a TypeScript toolkit for applications where AI agents, humans, workflows, and business logic need to work together.

My core thesis is to treat the main units of work as event handlers. Agents, workflows, services, and humans all modelled as event handlers communicating across an event fabric. No architectural privileges. An agent coordinating with a workflow uses identical patterns to a workflow coordinating with a human.

Key characteristics: - Contract-first design with runtime validation (Zod-based) - Event driven durable execution with suspend/resume for orchestrations - State machines (XState) for structured workflows - Imperative orchestrations (Temporal style) for when state-machines becomes limiting - Infrastructure-agnostic (same code runs locally or on cloud) - Native OpenTelemetry integration

Built on CloudEvents, implements virtual orchestration through physical choreography. Handlers are stateless, workflows persist as JSON, everything composes naturally.

Open source, production-ready core, growing standard library (@arvo-tools).

Happy to discuss the architecture or answer questions about the design decisions.

Hi HN,

I built DBPiper after Sequin (YC W19) shut down

Problem: Teams use Postgres for production, Airtable for ops. Keeping them synced is painful.

Sequin solved this but shut down. Stacksync (replacement) is $1000/month. Too expensive for most teams.

DBPiper: Same real-time bidirectional sync, $15/month.

Link: https://dbpiper.netlify.app/

Tech: Go backend, Next.js frontend, uses webhooks + DB triggers for real-time sync.

Happy to answer any questions

I picked up a bass guitar for a new hobby, and wanted to learn how to play along to my favorite songs. I don't know how to read sheet music yet, and every 'tablature' interface out there either doesn't let you input your own songs, or has something missing from its total feature set that doesn't make it worth.

I set out to build a script that takes songs, splits out their bass stem, then analyzes the stem using pitch detection to find the notes being played. While it's not possible to know exactly which strings are being played for each note, a good guess can be made and played along to while I get better at playing and figure it out myself :)

The output scrolls along to the time of the song inside a normal browser window, with a crossfade slider to let you hear more of the original mix or more of the bass while you play along (i almost always have it set to 90% bass since im playing a fretless bass and i really need to hear the stem mix with my bass to make sure im playing the right note).

After I started playing with it for a while I realized I accidentally created a DDR / Guitar Hero clone to trick myself into practicing. Hope you have fun with it too!