2026년 3월 13일의 Show HN

Hi HN! I built Oxyde because I was tired of duplicating my models.

If you use FastAPI, you know the drill. You define Pydantic models for your API, then define separate ORM models for your database, then write converters between them. SQLModel tries to fix this but it's still SQLAlchemy underneath. Tortoise gives you a nice Django-style API but its own model system. Django ORM is great but welded to the framework.

I wanted something simple: your Pydantic model IS your database model. One class, full validation on input and output, native type hints, zero duplication. The query API is Django-style (.objects.filter(), .exclude(), Q/F expressions) because I think it's one of the best designs out there.

Explicit over implicit. I tried to remove all the magic. Queries don't touch the database until you call a terminal method like .all(), .get(), or .first(). If you don't explicitly call .join() or .prefetch(), related data won't be loaded. No lazy loading, no surprise N+1 queries behind your back. You see exactly what hits the database by reading the code.

Type safety was a big motivation. Python's weak spot is runtime surprises, so Oxyde tackles this on three levels: (1) when you run makemigrations, it also generates .pyi stub files with fully typed queries, so your IDE knows that filter(age__gte=...) takes an int, that create() accepts exactly the fields your model has, and that .all() returns list[User] not list[Any]; (2) Pydantic validates data going into the database; (3) Pydantic validates data coming back out via model_validate(). You get autocompletion, red squiggles on typos, and runtime guarantees, all from the same model definition.

Why Rust? Not for speed as a goal. I don't do "language X is better" debates. Each one is good at what it was made for. Python is hard to beat for expressing business logic. But infrastructure stuff like SQL generation, connection pooling, and row serialization is where a systems language makes sense. So I split it: Python handles your models and business logic, Rust handles the database plumbing. Queries are built as an IR in Python, serialized via MessagePack, sent to Rust which generates dialect-specific SQL, executes it, and streams results back. Speed is a side effect of this split, not the goal. But since you're not paying a performance tax for the convenience, here are the benchmarks if curious: https://oxyde.fatalyst.dev/latest/advanced/benchmarks/

What's there today: Django-style migrations (makemigrations / migrate), transactions with savepoints, joins and prefetch, PostgreSQL + SQLite + MySQL, FastAPI integration, and an auto-generated admin panel that works with FastAPI, Litestar, Sanic, Quart, and Falcon (https://github.com/mr-fatalyst/oxyde-admin).

It's v0.5, beta, active development, API might still change. This is my attempt to build the ORM I personally wanted to use. Would love feedback, criticism, ideas.

Docs: https://oxyde.fatalyst.dev/

Step-by-step FastAPI tutorial (blog API from scratch): https://github.com/mr-fatalyst/fastapi-oxyde-example

We built an open-source proxy that sits between coding agents (Claude Code, OpenClaw, etc.) and the LLM, compressing tool outputs before they enter the context window.

Agents are terrible at managing context. A single file read or grep can dump thousands of tokens into the window, most of it noise. This isn't just expensive — it actively degrades quality. Long-context benchmarks consistently show steep accuracy drops as context grows (OpenAI's GPT-5.4 eval goes from 97.2% at 32k to 36.6% at 1M https://openai.com/index/introducing-gpt-5-4/).

Our solution uses small language models (SLMs): we look at model internals and train classifiers to detect which parts of the context carry the most signal. When a tool returns output, we compress it conditioned on the intent of the tool call—so if the agent called grep looking for error handling patterns, the SLM keeps the relevant matches and strips the rest. If the model later needs something we removed, it calls expand() to fetch the original output. We also do background compaction at 85% window capacity and lazy-load tool descriptions so the model only sees tools relevant to the current step.

The proxy also gives you spending caps, a dashboard for tracking running and past sessions, and Slack pings when an agent is sitting there waiting on you.

Repo is here: https://github.com/Compresr-ai/Context-Gateway. You can try it with:

  curl -fsSL https://compresr.ai/api/install | sh

Happy to go deep on any of it — on the compression model, how the lazy tool loading works, or anything else about the gateway. Try it out and let us know how you like it!

I started writing this book 10 years ago in JavaScript, got through a few chapters (asymptotic notation, basic techniques, start of sorting), and then abandoned it.

Recently I picked it back up, converted everything to TypeScript, and used AI (Zenflow [1] + Claude Opus 4.6) to complete the remaining chapters. I provided the structure, direction, and initial chapters; the AI generated the bulk of the remaining content under a spec-driven workflow.

The book covers roughly a first 1-2 year CS curriculum: sorting, dynamic programming, graph algorithms, trees, heaps, hash tables, and more. All code is executable, typed with generics/interfaces, and covered with tests.

I've thoroughly reviewed several chapters (sorting, DP, graphs) and done a high-level pass on the rest. Currently in beta — corrections and contributions are welcome.

MIT licensed. Inspired by Wirth's "Algorithms and Data Structures", SICP, and CLRS.

Code and tests: https://github.com/amoilanen/Algorithms-with-Typescript

[1] https://zencoder.ai/zenflow

This is a small coding toy I made for fun. I think there are a few interesting ideas buried in it — curious what others think.

Hey HN,

My cofounder and I have gotten tired of CC ignoring our markdown files so we spent 4 days and built a plugin that automatically steers CC based on our previous sessions. The problem is usually post plan-mode.

What we've tried:

Heavily use plan mode (works great)

CLAUDE.md, AGENTS.md, MEMORY.md

Local context folder (upkeep is a pain)

Cursor rules (for Cursor)

claude-mem (OSS) -> does session continuity, not steering

We use fusion search to find your CC steering corrections.

- user prompt embeddings + bm25

- correction embeddings + bm25

- time decay

- target query embeddings

- exclusions

- metadata hard filters (such as files)

The CC plugin:

- Automatically captures memories/corrections without you having to remind CC

- Automatically injects corrections without you having to remind CC to do it.

The plugin will merge, update, and distill your memories, and then inject the highest relevant ones after each of your own prompts.

We're not sure if we're alone in this. We're working on some benchmarks to see how effective context injection actually is in steering CC and we know we need to keep improving extraction, search, and add more integrations.

We're passionate about the real-time and personalized context layer for agents. Giving Agents a way to understand what you mean when you say "this" or "that". Bringing the context of your world, into a secure, structured, real-time layer all your agents can access.

Would appreciate feedback on how you guys get CC to actually follow your markdown files, understand your modus operandi, feedback on the plugin, or anything else about real-time memory and context.

- Ankur

Hi HN - I'm Ryan a product designer who codes, and I built Mesa. Current IDEs feel wrong for the type of development being done now - the focus is still on files.

Mesa puts the focus on the full workflow: your agent, terminal, browser, and files all live as equal nodes on a canvas with full multiplayer support. (think figma but for code)

I was tired of the overhead of switching windows, tabs, and terminals across multiple projects. Inspired by TouchDesigner and Factorio, I wanted something more fluid and visual. Been using it as a total replacement for Cursor at work every day now. Being able to see multiple repos at once and control agents on each without navigating windows has freed up my headspace and increased productivity.

It's free to try — would love to know what you think!

I’ve been experimenting with infrastructure for multi-agent systems.

I built a small project called AgentLog.

The core idea is very simple, topics are just append-only JSONL files.

Agents publish events over HTTP and subscribe to streams using SSE.

The system is intentionally single-node and minimal for now.

Future ideas I’m exploring: - replayable agent workflows - tracing reasoning across agents - visualizing event timelines - distributed/federated agent logs

Curious if others building agent systems have run into similar needs.

I work on AWS infrastructure (ex-Percona, Box, Dropbox, Pinterest). When OpenClaw blew up, I wanted to run it properly on AWS and was surprised by the default deployment story. The Lightsail blueprint shipped with 31 unpatched CVEs. The standard install guide uses three separate curl-pipe-sh patterns as root. Bitsight found 30,000+ exposed instances in two weeks. OpenClaw's own maintainer said "if you can't understand how to run a command line, this is far too dangerous."

So I built a Terraform module that replaces the defaults with what I'd consider production-grade:

* Cognito + ALB instead of a shared gateway token (per-user identity, MFA) * GPG-verified APT packages instead of curl|bash * systemd with ProtectHome=tmpfs and BindPaths sandboxing * Secrets Manager + KMS instead of plaintext API keys * EFS for persistence across instance replacement * CloudWatch logging with 365-day retention Bedrock is the default LLM provider so it works without any API keys. One terraform apply. Full security writeup: https://infrahouse.com/blog/2026-03-09-deploying-openclaw-on...

I'm sure I've missed things. What would you add or do differently for running an autonomous agent with shell access on a shared server?

Hey HN, I often wish I could go back to some year and listen to the radio as it played then, with songs that fit that time period.

But not every moment is the same, and humans turn to music for various purposes. Genres feel arbitrary and limiting, so I thought it would make more sense to create stations based on a specific vibe. Are you looking for something chill or intense? Alone, or with friends? Is this a dinner party, a dance floor, or a moment alone afterhours?

So I built Anthrology as a way to navigate across time and mood. I've been listening to it pretty much nonstop for a couple of days, and I hope you'll enjoy it too.

Songs are already playing by the time you tune to a year and vibe. You can tune to some other moment and come back, and the track will still be playing—but you'll have missed a little bit of the song, just like the radio!

And the radio is (more or less) deterministic, so we all hear the same tracks.

Tune in and enjoy!

I'm a VP of Engineering with 20 years in the field. I've been thinking deeply on why AI is breaking every engineering practice, and it led me to the conclusion that the Agile Manifesto's values need updating.

The core argument: AI made producing software cheap, but understanding it is still expensive. The Manifesto optimizes for the former. This addendum shifts the emphasis toward the latter.

Four updated values, three refined principles, with reasoning for each. Happy to discuss and defend any of it.

Post-Opus 4.6, LLMs feel much better at using bash, code, local files, and tools.

So I kept coming back to a simple question: if a model can use a computer reasonably well, why can’t I just give it my broker account, a strategy, and let it trade?

My conclusion is that the blocker is not model capability in the abstract. It is the system around the model.

A raw LLM breaks on a few practical things almost immediately:

• no persistent operating memory across sessions • no trustworthy record of what it did and why • no hard approval boundary before money moves • no cheap always-on monitoring if every check requires an LLM call • no reliable enforcement of limits, permissions, or workflow rules unless that lives outside the model

So the problem is not really “can the model call a broker API?” The problem is that trading needs a harness.

My friend and I built one for this called Vibe Trade. It is open source, MIT licensed, and currently runs locally on your machine connected to Dhan.

The basic design is:

1. Immutable trade journal Every action is logged at decision time with timestamp, reasoning, and observed signals. The agent cannot rewrite its own history after the fact.

2. Hard approval gate Before any order is placed, the system generates a structured approval request. Execution is blocked until the user approves. This is enforced in code, not left to the model’s discretion.

3. Event loop outside the LLM Market watching is handled in plain JS on a timer. Price checks, time rules, and indicator thresholds run every 30 seconds without invoking the model. The LLM only wakes up when something needs reasoning.

4. Playbooks / skill files Strategies live in markdown documents that get loaded as operating context on each decision. Example: “replicate the Nifty Defense Index and rebalance weekly.” This gives the agent a stable workflow definition instead of relying on chat history.

The first use case that made this feel real to me was very unglamorous: portfolio rebalancing.

I used to make Smallcase-style index replication portfolios and then forget to rebalance them on time. With this setup, I can define the strategy once, let the non-LLM layer monitor for conditions, and have the agent prepare actions for approval. That was the first point where it stopped feeling like a demo and started feeling useful.

A few caveats: • UI is still weak; it is mostly a chat interface right now • Dhan only for now • local install only for now • requires Node.js and an Anthropic API key

Repo: github.com/vibetrade-ai/vibe-trade

I’m posting this mainly because I think more people will try building “LLM as operator” systems now that tool use is better, and finance makes the failure modes very obvious.

The questions I’m interested in are:

• What other harness components are missing for something like this?

• Would you trust a local system like this more than a hosted one, or less?

• What repeatable financial workflows would you automate first?

Hi HN,

I'm a self-taught developer from Malawi, and I built DJX because I was tired of writing the same Django boilerplate over and over.

Django is powerful, but starting a new feature means manually creating models, views, templates, URLs, and wiring everything together. Rails solved this 20 years ago with scaffolding. Django deserves the same.

DJX brings convention over configuration to Django:

    pip install djx-cli                                                                                            
    djx new myblog && cd myblog                                                                                    
    djx scaffold Post title:string content:text published:boolean                                                  
    python manage.py migrate && python manage.py runserver                                                         
    # → http://127.0.0.1:8000/posts/ — full CRUD. Done.                                                            
                                                                                                                   

That's it. You get list, create, edit, and delete views with templates, all wired up automatically.

Other commands: - `djx routes` — see all URL routes (Django doesn't have this built-in) - `djx destroy scaffold Post` — clean removal of generated code - `djx add django-crispy-forms` — install and auto-add to INSTALLED_APPS - `djx model`, `djx controller` — generate pieces individually

It follows Rails conventions: pluralized app names, RESTful URLs, automatic timestamps, and sensible defaults.

I built this because I wanted Django development to feel as fast as Rails. It's early stage, but it's already saving me hours on every project.

PyPI: https://pypi.org/project/djx-cli/ GitHub: https://github.com/RedsonNgwira/djx-cli

Would love your feedback and contributions. What other Rails-like features would make Django development faster?

I'm sharing a userscript for for those who read the HN comments section a lot:

1. Updates comments without reloading the page — instantly see new ones as they appear.

2. Cleaner comment topline for less distraction — shows controls only when you hover over the topline.

There is a preview gif of how it looks in the README.

Why are you reading this? Click the link, stupid.

Got real tired of juggling five tabs and a terminal to compress different file types. So I built something that handles them ALL in one place.

Supports 50+ input formats. If something is compressible it will handle it. Upload a file, it figures out what it is, compresses it, hands it back. Ephemeral storage for 2 hours. Format conversion works pretty well too.

The part I'm most happy with is the detection layer. For binary formats, magic bytes get you most of the way there. For text-based (JS, CSS, JSON, XML, etc) I run a small ML classifier on the content itself to identify the format and route it to the right compression pipeline without asking the user to specify.

REST API if you want to plug it into a pipeline. Webhooks for async jobs, bring-your-own-storage for S3/GCS/Azure/whatever. Batch jobs work well.

No signup required, free tier with very generous monthly quota. Feedback, edge cases that break the detector, feature requests - all welcome.

I just released chat.nvim v1.4.0, an AI chat plugin that runs entirely inside Neovim.

The idea is to turn Neovim into an AI hub instead of just a prompt box. You can chat with LLMs, run tools, and even bridge messages from external chat platforms.

Features:

- Multiple providers (OpenAI, Gemini, Anthropic, Ollama, etc.) - Tool system (web search, file search, git diff, etc.) - Long-term memory - Multiple sessions - Streaming responses - Chat integrations (Discord, Telegram, Lark, WeCom, DingTalk)

The plugin is written in Lua and designed to be lightweight and hackable.

Repo: https://github.com/wsdjeg/chat.nvim

Release: https://github.com/wsdjeg/chat.nvim/releases/tag/v1.4.0

Feedback is very welcome.

Hi HN,

I built Build4Me to address a trust problem in diaspora-funded construction projects.

Many families send money home to build houses but have no reliable way to verify that work is actually being done. Photos can be reused, progress exaggerated, or projects abandoned after funds are sent.

Build4Me introduces milestone-based funding where each construction milestone must be verified before funds are released.

The system verifies progress using: - geotagged photo capture - GPS location verification - AI image analysis - duplicate image detection

It runs on serverless AWS architecture using services like Rekognition, Bedrock, Lambda, DynamoDB, and Amazon Location Service.

Would love feedback on the architecture and fraud detection approach.

Hi HN,

This is a tool I've worked on the past few months.

Instead of giving LLM tools SSH access or installing them on a server, the following command:

  $ promptctl ssh user@server

makes a set of locally defined prompts "magically" appear within the remote shell as executable command line programs.

For example, I have locally defined prompts for `llm-analyze-config` and `askai`. Then on (any) remote host I can:

  $ promptctl ssh user@host 
  # Now on remote host
  $ llm-analyze-config /etc/nginx.conf
  $ cat docker-compose.yml | askai "add a load balancer"

the prompts behind `llm-analyze-config` and `askai` execute on my local computer (even though they're invoked remotely) via the llm of my choosing.

This way LLM tools are never granted SSH access to the server, and nothing needs to be installed to the server. In fact, the server does not even need outbound internet connections to be enabled.

Eager to get feedback!

Github: https://github.com/tgalal/promptcmd/

Hey HN!

I have been working with mjml and handlebars for a very long time, but I really miss the type-safety of JSX syntax paired with Typescript and component composition. So I wanted to to combine mjml with jsx. There are libraries like mjml-react or react.email, but for no apparent reason, they seem to depend on react.

So I decided to create mjmx[0] - a standalone, zero dependencies (other than mjml), custom jsx runtime for rendering mjml. Appreciate if you would give a try and provide some feedback.

[0] https://mjmx.dev/

Hi HN,

I’m the creator of Sapphire, a lightweight programming language written in C++ designed to hit the "sweet spot" between high-level ease of use and low-level performance. I’ve just released version 1.0.7, which is our final push before the 1.1 LTS (Long Term Support) version.

The goal of Sapphire is simple: Zero friction. No complex installers, no pip install, no npm headaches. Just a single 12MB binary that gives you everything you need to build UI tools, network apps, or performance-critical scripts out of the box.

What’s new in 1.0.7: Vector Math: Added native support for 2D and 3D vectors, making it much easier to build games or simulations (check the Raycaster link below).

Syntax Fluidity: We’ve relaxed the syntax rules to make coding feel more natural and less "rigid" without sacrificing the speed of the VM.

LTS Preparation: Focus on stability and bug fixes as we approach our first Long Term Support milestone.

Key Features: Immediate Mode UI: Built-in UI engine (SapphireUI) using SFML for rendering. You can create windows and buttons instantly without external DLLs.

High-Performance VM: Uses Direct Threading (Computed GOTOs). It handles 100 million iterations in ~9 seconds on a standard consumer CPU.

No Imports Needed: Native support for Terminal colors, JSON parsing, HTTP functions, and System communication is baked into the core.

Portable: Download the .exe, add to PATH, and you're ready. The VM + UI + Networking + JSON is all in one 12MB file.

Try it out: Repo: github.com/foxzyt/Sapphire

Raycaster: github.com/foxzyt/SapphireRaycaster

I built a macOS voice dictation app where zero bytes of audio ever leave your machine.

EdgeWhisper runs Voxtral Mini 4B Realtime (Mistral AI, Apache 2.0) locally on Apple Silicon via the MLX framework. Hold a key, speak, release — text appears at your cursor in whatever app has focus.

Architecture: - Native Swift (SwiftUI + AppKit). No Electron. - Voxtral 4B inference via MLX on the Neural Engine. ~3GB model, runs in ~2GB RAM on M1+. - Dual text injection: AXUIElement (preserves undo stack) with NSPasteboard+CGEvent fallback. - 6-stage post-processing pipeline: filler removal → dictionary → snippets → punctuation → capitalization → formatting. - Sliding window KV cache for unlimited streaming without latency degradation. - Configurable transcription delay (240ms–2.4s). Sweet spot at 480ms.

What it does well: - Works in 20+ terminals/IDEs (VS Code, Xcode, iTerm2, Warp, JetBrains). Most dictation tools break in terminals — we detect them and switch injection strategy. - Removes filler words automatically ("um", "uh", "like"). - 13 languages with auto-detection. - Personal dictionary + snippet expansion with variable support ({{date}}, {{clipboard}}). - Works fully offline after model download. No accounts, no telemetry, no analytics.

What it doesn't do (yet): - No file/meeting transcription (coming) - No translation (coming) - No Linux/Windows (macOS only, Apple Silicon required)

Pricing: Free tier (5 min/day, no account needed). Pro at $7.99/mo or $79.99/yr.

I'd love feedback on: 1. Would local LLM post-processing (e.g., Phi-4-mini via MLX) for grammar/tone be worth the extra ~1GB RAM? 2. For developers using voice→code workflows: what context would you want passed to your editor? 3. Anyone else building on Voxtral Realtime? Curious about your experience with the causal audio encoder.

Hi HN,

I built a small open-source tool called Privacy Mask.

It intercepts screenshots locally and automatically redacts sensitive patterns (API keys, phone numbers, IDs, etc.) before screenshots are sent to AI tools or agents like OpenClaw.

The goal is to prevent accidental data leaks when sharing screenshots during debugging or development.

Everything runs locally.

Would love feedback.

My wife and I have our Apple TV screensaver set to favorites photo album. Except we don’t update it much so it was getting boring.

Enter the solution to any and every problem (can you guess?) —em dash— AI!

Introducing imagemine → →

Try it by running `uvx imagemine path/to/photo.jpg`

At its heart, imagemine is a simple “ask claude for a short surrealist story based on the input photo” then “have nano banana generate a new image from the story and source image” script.

imagemine has 35+ built-in style prompts included that get selected at random or you can add your own (one-off cli flag or added to store).

Sure it might be slop, but it's your slop, curated with your magnificent taste.

The kicker is that you can configure an input and output Photos album (if you’re on a Mac) so that my old favorites album is source material and my TV is now set to the new album.

imagemine includes optional launchd (Mac’s cron, to oversimplify) so this whole thing can be run automatically on a schedule. Set it, forget it, give Anthropic and Google your money on autopilot.

If you use it, I’d love to hear feedback!

I got tired of rebuilding the same pulsing circle every time I prototyped a voice AI app, so I packaged it up.

orb-ui is a React component library for voice AI agent UIs. You plug in an adapter for your voice provider, the component handles the state machine (idle, connecting, listening, speaking) and renders it.

  import { Orb } from 'orb-ui'
  import { createVapiAdapter } from 'orb-ui/adapters'
  
  <Orb adapter={createVapiAdapter(vapi, { assistantId })} theme="circle" />

Click the orb to start/stop. Animation reacts to audio volume in real time.

The existing alternatives (ElevenLabs UI kit, Vapi Blocks) are shadcn-style copy-paste components locked to one provider. This is a proper package you can install and update.

Demo: https://orb-ui.com

npm: https://www.npmjs.com/package/orb-ui

GitHub: https://github.com/alexanderqchen/orb-ui

Curious what voice AI UIs people are building and what you'd want from a library like this.

Harbor crossed its 127th (next one is special) release.

One notable added feature is ability to manage all my LLMs with a single CLI.

# list all models harbor ls # pairs well with jq harbor ls --json # Ollama harbor pull qwen3.5:35b # llama.cpp harbor pull unsloth/Qwen3.5-35B-A3B-GGUF:Q8_0 # vllm (HuggingFace Hub cache) harbor pull Qwen/Qwen3.5-35B-A3B

# Remove any of the models by the same id # used to pull it harbor rm <id>

Hopefully it'll be useful for someone too.

We're former AWS S3 engineers. Row Zero is "Google Sheets on steroids". We built it because we were frustrated with Excel's 1 million row limit and poor integration with cloud data sources like S3, Postgres, Snowflake, and Databricks.

Under the hood, the spreadsheet engine is a columnar key-value store written in Rust. We built it from scratch because SQL engines like DuckDB only work well for structured tables. The unstructured nature of spreadsheets make them a bad fit for SQL. The engine also needs to be 100% Excel compatible so you can import existing xlsx files.

The front-end is a big React app with hand-rolled canvas rendering. We virtualize scrolling to handle 2 billion+ row data sets. All workbook state runs in the cloud (located in a data center close to you to keep things snappy).

We launched on HN 2 years ago and got lots of great feedback. Since then, customers have pulled us towards the enterprise. Today we're launching Row Zero 2.0 with support for all the enterprise bells and whistles: OAuth database connections, SSO, SCIM, workspaces, private link on AWS and Azure, bring your own AI key, and private storage. Excited to hear what you think.

Hi HN,

I’ve been experimenting with autonomous agents for the past year, and I kept running into the same uncomfortable problem:

Agents were making decisions I couldn’t fully see or justify.

They could call tools, trigger actions, and make assumptions based on incomplete context. Once systems start touching real infrastructure, that becomes pretty scary.

So I built DashClaw.

DashClaw sits between an agent and the tools it wants to use. Instead of executing actions directly, agents call DashClaw first.

DashClaw can:

• evaluate the decision • apply policy rules • require approval • log reasoning and assumptions • record the final outcome

The idea is to create a *decision trail* for agent systems so you can answer:

Why did the agent think this was okay? What information did it rely on? Who approved the action?

The project includes:

• Node and Python SDKs • a decision ledger for agent actions • policy guardrails before execution • a mission control dashboard for fleet activity • a self-hosted architecture

It’s completely open source and designed to be lightweight enough to run locally with agent frameworks.

I'm still figuring out what the right abstraction layer is for this kind of infrastructure, so I’d love feedback from people building agents.

Repo: https://github.com/ucsandman/DashClaw