Show HN for June 15, 2026

Hi! me and my friends together built an 8 bit CPU implemented in Logisim purely from scratch. The control unit of this system does not implement the generic microcode ROM or any kind of RAM. This was made purely from discrete logic gates and coded the system to run different programs.

key features: Custom 16-instruction Harvard ISA, 8-bit fixed format, 4 general purpose registers

Hardwired control unit built entirely from AND/OR gate logic matrix

Dual-phase clocking to eliminate race conditions

Bootstrap Control Unit that cold-boots via ROM-to-RAM transfer Early-exit conditional branching that saves upto 25% cycles when conditions aren't met

Full design specification document with version control

Since this was our first time doing such teamwork and a new thing we used RISC based system that fetches an 8-bit instruction from Instruction memory 4 bits of which translate to an instruction the last two bits are for source and destination registers. There are a total of 4 registers in the system with two memory units namely Data SRAM and I SRAM, the system follows a Harvard architecture.

There are design discrepancies too since it was our first time designing such a system and on top of that completely hardwired too.

To solve the problem of cold booting a bootloader is present too that copies the contents of a temporary ROM into instruction RAM and then hands over the reins to the CPU.

We also implemented conditional branching as well as early exit branching too that only checks for zero or carry flag and branches without wasting cycles, if the conditions are not met the Program counter increments.

Moreover we also created a complete documentation with version control describing each necessary part assuming prior knowledge.

Please take a look at it at https://github.com/c0rRupT9/STEPLA-1

For future development I want to implement a RISC CPU using FPGA's and connect it to an actual DRAM. We are also selling the full spec document and Logisim files for $5 to fund our passion https://tcfdiq.gumroad.com/l/zyyux Thankyou!

Hi HN! Excited to launch machine0, a CLI that makes it easy to create, provision and snapshot persistent NixOS (& Ubuntu) VMs.

You can think of machine0 as a modern VPS provider. VMs stay on unless switched-off (with 99.99% uptime), they have static IPs and HTTPS endpoints, 1-60 vCPU, up to 240GB RAM and optionally GPUs. The CLI provides commands to manage lifecycle, snapshots and also provision the VMs using Nix flakes or Ansible playbooks. VMs are priced by the minute of usage.

What makes machine0 unique is that it has first class support for NixOS! In a nutshell, NixOS lets you define your entire OS as code (think Terraform but for your Linux). A flake declares your system state (packages, services, firewall rules, users...) and pins all dependencies via a lockfile. Given the same flake.nix and flake.lock, `nixos-rebuild switch` always produces the exact same system.

The NixOS ecosystem is mature, and flakes are expressive: at the system level you can define packages, what's in /etc, firewall rules, users & groups etc. At the user level, you can define your shell, aliases, tmux and vim config. Having your entire environment defined as code makes it easy to audit what's installed and how things are set up. You can rollback by reverting the last commit. And agents can write the code for you and test it against disposable machine0 VMs.

If you'd like to dive right in, these commands will get you started:

  npm install -g @machine0/cli
  machine0 new my-vm --image nixos-25-11        # create a new nixos VM
  machine0 provision my-vm ./flake#my-profile   # provision it using a nix flake
  machine0 ssh my-vm                            # ssh in
  machine0 stop my-vm                           # stop the VM
  machine0 images new my-vm my-snapshot         # create a snapshot
  machine0 new my-clone --image my-snapshot     # create a new VM from the snapshot

- Demo of installation + NixOS provisioning via Claude Code: https://www.youtube.com/watch?v=RT8N0_e3Vfg

- Documentation: https://docs.machine0.io/introduction/overview

- machine0 NixOS flakes: https://github.com/fdmtl/machine0-nixos

If you're in the habit of using VMs, or want to know what the NixOS fuss is about, would love for you to give machine0 a try!

I know, it's kind of weird. What is a veterinarian doing creating an analysis tool for lawn problems?

Frankly, the idea was born of my own lawn care struggles. Endless lawn care company fees without any actual improvement. Googling problems and finding generic solutions without regional considerations. One time I overseeded my grass not realizing I had to actually put soil down too.

One day, I decided to run lawn pictures through AI and found some pretty helpful information. So I decided with my clinical background (the idea of treating the cause, not just the symptoms), as well as tech savvy, I would create an AI tool where homeowners can upload pictures of their lawn, enter their ZIP code, and get a diagnosis tailored to their location with actionable next steps in just 15 seconds.

Completely free. The platform is monetized with affiliate sales (if a user elects to purchase through one of our Amazon or other links) and by selling exclusive rights to individual ZIP codes to lawn care companies seeking warm leads. Users can pursue their own DIY plan, purchase a lawn care subscription service, or contact a local lawn care system.

I'd love if you'd test it out, toy with it, try to break it, and give me your feedback. Any feature requests would be super helpful.

Thanks! Excited to hear your thoughts.

Andrew

I've been working on deconvolution, a comprehensive Rust image deconvolution and restoration library. Deconvolution implements 28 different image deconvolution/restoration methods which range from practical blur removal techniques to research-grade scientific imaging algorithms.

Features:

- Top-level functions use image::DynamicImage and return images

- Inverse filters, Wiener, Richardson-Lucy, constrained, proximal, Krylov, MLE restoration

- Blind Richardson-Lucy, blind maximum likelihood, parametric PSF estimation

- Kernel2D, Kernel3D, Transfer2D, Transfer3D, Blur2D/Blur3D

- Gaussian, motion, defocus, microscopy models, support utilities, PSF/OTF conversion

- Edge tapering, apodization, range normalization, NSR estimation

- Deterministic blur, noise, synthetic fixture generation

- ndarray support for 2D image arrays and 3D volume

this project is a WIP, of course:)

VS Code and JetBrains have official Claude Code IDE integration, but Visual Studio doesn't. There's an open GitHub issue with a lot of +1s so I built it myself (check out the gif in the GitHub repo for a visual example).

It implements the same protocol the official plugins use, so the Claude CLI connects to it automatically. You don't configure anything, just install the extension and click Launch.

The main thing it adds over running Claude in a terminal is that edits open in Visual Studio's native diff viewer instead of auto-applying or prompting you in the terminal. You click Accept or Reject right there. You can also reject with a reason, and Claude will take another pass.

It also shares your compiler errors (C# and C++) and your current selection with the CLI automatically, so Claude has context without you having to copy-paste anything.

A few other things: - There's a dockable panel with connection status and token/cost stats for the session - A "run wild" toggle to auto-accept edits without opening the diff Works with the existing claude CLI, no model calls of its own

Marketplace: https://marketplace.visualstudio.com/items?itemName=firish.b...

GitHub: https://github.com/firish/claude_code_vs

Data driven browser system

This sounds clickbait, but it’s true: I used Claude Mythos to build the full site in 1 day. Then Anthropic removed the model, so I had to go back to Opus.

I use this as my regular xterm replacement... Why? Because I can.

It's pure-Ruby down to the font-renderer, and the X11-bindings.

(I also run a Ruby WM, a Ruby editor, file manager, and more, so this is just par for the course of my descent into madness)

It supports double-width and double-height text, unicode (but double-width characters may currently be rescaled down), layering fonts, special rendering of box-drawing characters (to ensure they seamlessly scale and connect, and has reasonably complete vt-100/vt-102 emulation. The whole thing is available as a Rubygem and comes with an ANSI text backend, so you can run your terminal in your terminal. The bulk was written manually, but the last few days I had Claude write a test harness to shake out a bunch of bugs, and start refactoring and cleaning up the code base (it's still full of warts).

Blog post about how we extended our open source profiler to include support for continuous production PC sampling.

Hey y'all,

So - the main idea of this is to make a WebAudio synthesis/sequencer tool which humans can use via the UI, but where the big unlock is for agents to drive with MCP

It's semi decent as "make a groovy jazz track", especially for retro sounds - but the real use case is more like "make a jetpack whoosh effect I can control via code at runtime - where the sound changes based on character health or how much fuel is left"

In other words, the target audience is not musicians (except maybe of the Max/MSP sort), but more like creative coders who want to shape the sound iteratively with an agent, and then use and _drive_ in in a game/simulation.

Fwiw I think this approach is going to be more and more... and I'm working on a renderer/editor tool too (will share separately when ready). What I mean is, there's a lot of "block box" AI tooling out there, and a lot of "add MCP to existing tools", but building new tools where humans get one experience and MCP exposes another layer really just for agents.. I think that's powerful.

Most if it is just mapping the WebAudio primitives to a UI and MCP server - but the AudioWorklet is a bit more interesting in that it expects a WASM file of a particular shape, and then uses that to expose the parameters in the UI and hook in as a Digital Signal Processor. That's the kind of thing that is nice for humans, but too convoluted to be usable in a UI, and agents can use super easily.

As of right now, there's no hosting - so the MCP server is local as is project save/loading.

Repo: https://github.com/awsm-fun/awsm-audio

Crates: https://crates.io/search?q=awsm-audio

Hi HN! I was super frustrated at apps like tiktok and wechat preventing me from saving or downloading the animated gifs, so I made a little tool to turn a screen recording into a slack-sized emoji. Hope you get some value from this!

I used to go back and forth between HN and Github and look for trending repos. Now i can see them all in one space. And it auto-updates.

Hello, we're the Treenix team.

We're building typed low-code runtime where humans and agents collaborate to build applications and workflows.

Write a simple TypeScript class with methods, and Treenix automatically delivers admin interface, storage, API and MCP, access rules, UI form and audit trail.

Views in Treenix are reactive, data-bound, and synced across all clients. They also support display contexts: data can render differently depending on the situation — a table in one place, a list in another. You can register multiple Views for the same data type, and the view engine picks the right one automatically based on context. Please, see the demo for more.

All the data, type, and view is the Treenix module, it live in one unified tree and could be composed in app

We're launching an alpha version to share the idea and receive your feedback. The code is open source and available on GitHub (https://github.com/treenix-io/treenix). This is the first public release, so you may run into issues.

You can try Treenix locally: npx create-treenix@latest

Demo video: https://youtu.be/ZCU_Y-khmJo

Landing: https://treenix.io

Brief - https://treenix.io/docs/brief.md

Documentation: https://treenix.io/docs

Hey HN! We're launching Macro (macro.com) — an open source, AI-native system that unifies email, chat, tasks, calls, docs, and CRM in one interface with shared memory.

Before Macro, we ran our startup on Superhuman + Slack + Notion + HubSpot + Linear. Each of these apps are good but they don't talk to each other, they're proprietary and closed off. We wanted one unified system, open source, with shared memory, that we could build our company around.

Macro is built to be modular and fast. It's designed to be your command center, your operating system. There's still a lot left to do.

We're currently working on CRM, Pull Requests / GH integration, and making Macro even more extensible. You can self-host or use the hosted version. Pls let me know what you think! You can open a PR on the repo or leave feedback here and we'll work on it.

I'm excited to share "take 2" of the Prela query language.

After sharing the previous version here, I've received some valuable feedback, the main one being the weird unicode-based syntax throwing people off.

Prela now has a more familiar SQL-like syntax while adhering to the algebraic principle, which makes the language compositional and controllable, all the while keeping the core engine under 1k lines of code.

The engine has also been rewritten from Julia to Rust, resulting in both simpler code and faster performance (not just because "Rust fast Julia slow", but for some pretty deep compiler-level reasons that I'll hopefully write about at some point).

In the long run, I think the value of Prela is not as a single query language, but as a demonstration of the power of relation combinators which can be implemented in any language, just like iterators.

Hey HN,

I've had this idea stuck in my head ever since I published Year in Pixels [1]. I've been adding a little thing here and there to this app, and now it feels nice enough to share.

It's very interesting what daily tracking does to one's mind. While I already have apps to track everything else like sleep, heart rate, etc., I was still missing something to track my mood. The simple act of thinking about how you feel a couple of times a day already changes things. A moment of reflection.

I opted to add Astrology, Checks (habits), and other goodies. Hope you like it as much as I do.

Best, @kinduff

[1]: https://news.ycombinator.com/item?id=16199871

We released what I've been working in the last few months: an Openclaw plugin that ecords every session, tool invocation, and prompt exchange into a local SQLite database with SHA-256 hash chain integrity, so you can verify that no events were altered or deleted after the fact.

I needed a classifier for nuanced, subjective buckets that fell outside of typical ML use-cases (e.g., "is this a spoiler?", "is this factually correct?", "is this user being mean?"). I ended up really happy with the architecture I built to solve it, so I rolled it out as a standalone API and service called CriteriaBot.

WHAT IT DOES:

You give it content and plain-English criteria. It gives you a true/false verdict on whether the content meets those criteria.

HOW IT WORKS:

In addition to a traditional classifier, the classification request is routed through a pool of small, open-weight LLMs to achieve a consensus verdict.

I built a pre-vote factorization machine that selects a sub-pool of LLMs optimized for signal strength based on the embedding of the subject/category. A second factorization machine then reads the votes and the embedding to arrive at a single verdict. That verdict is dynamically modified based on the user's history of agreement/disagreement with the models in semantically similar evaluations.

The models are also hooked up to Wikipedia and Wolfram to support edge cases requiring current information or mathematical grounding.

FINDINGS:

* With the same harness and sample set, Gemma 4 26B's accuracy is only ~1 percentage point below Opus 4.8.

* Pure oracle is theoretically very good - currently ~98% accuracy for the datasets. I'm using the second factorization machine as a combiner as it can theoretically push past oracle results, but it's an interesting fallback.

* The single most useful LLM surprised me - LFM2 24B contributes the most to the consensus, despite being the worst individually (of the current pool of LLMs). It correlates the least with the other models (perhaps due to its unique architecture?) which makes it a useful signal for some of the problems.

* The legal obligations of handling user-submitted images are... involved. I've disabled image support for non-me users while I sort that out (in case you were hoping to try out "Hotdog, Not Hotdog").

* Rails singularizes "criteria" as "criterium" and I didn't realize that was incorrect until it was kind of a lot of work to fix.

WHY I'M POSTING: I’d been dealing with burnout for a while, and getting this running has been incredibly rewarding. The majority of people in my personal life are non-technical so it's been hard to get reactions to it beyond "what is it?".

Would be thrilled with whatever honest feedback you have.

I spent the past year building Micro Coach with two partners.

It creates personalized 4-week training blocks based on your goals, schedule, experience level, equipment, and preferences. Users can also generate individual workouts, track progress, and view training analytics.

I built it using my background in both software engineering and personal training.

I’d appreciate feedback on the onboarding, workout generation, and overall product experience:

https://microcoachapp.com

The honest, local-first usage meter for AI coding tools. Claude Code, Codex, Kimi, Qwen CLI, HashCortx, HashCerebrum — unified into one clean dashboard with usage based trophies :)

Jet is a simple, lightweight, modern, turnkey, Java web client and server library.

Jet offers four modules: Common, Server, OpenAPI Annotations, OpenAPI Annotations Plugin, and Client.

Jet is a wrapper around the excellent Jetty web client and server library. Jetty provides the battle-tested low-level protocol handling, while Jet focuses on providing a modern and consistent interface with superb documentation and an amazing developer experience.

---

I built this Java library to fill a hole in the Java web server library ecosystem. Javalin got me 90% of the way there, but requires the Kotlin dependency and lacks header models and exhaustive KDocs. The Client module is a still a WIP, but the Server, OpenAPI Annotations, and OpenAPI Annotations Plugin modules are production-ready!

Check it out at: https://github.com/Petersoj/jet