2025年12月6日 的 Show HN

3D printing is such a fascinating field of technology, so a couple months ago, I decided to take a deep dive and learn how they actually work!

This took me to one of my very first PCB projects, a small, cheap, 3D printer motherboard. While it's not the most cutting edge board, I learned a lot and I fully documented my process designing it (https://github.com/KaiPereira/Cheetah-MX4-Mini/blob/master/J...), so other people can learn from my mistakes!

It runs off of an STM32H743 MCU, has 4 TMC stepsticks with UART/SPI configurations, sensorless/endstop homing, thermistor and fan ports, parallel, serial and TFT display connectors, bed and heater outputs and USB-C/SD Card printing, all in a small 80x90mm form factor with support for Marlin and Klipper!

Because it's smaller and cheaper than a typical motherboard, you can use it for smaller/more affordable printers, and other people can also reference the journal if they're making their own board!

If I were to make a V2, I would probably clean up the traces/layout of the PCB, pay more attention to trace size, stitching and fills, BOM optimize even further, and add another motor driver or two to the board. I also should've payed a bit more attention to how much current I would be drawing, and also the voltage ratings, because some of the parts are under-rated for the power.

I'm still actively refining it and fixing up some of the mistakes, but I plan on using this board to make a tiny foldup 3D printer I can bring to hackathons and 3D print on the go!

The project is fully open source, and journaled, so if you'd like to check it out it's on GitHub (https://github.com/KaiPereira/Cheetah-MX4-Mini)!

I absolutely loved making this project and I'd love to hear what you guys would want to see in a V2!

`cargo install tascli`

Manages your own task and records in the terminal simply with tascli - tiny, fast and simple.

Hi everyone, I built FuseCells, a minimalistic logic puzzle game where every level is handcrafted (no procedural generation). It started as a personal challenge to design a clean rule-set and scale it to thousands of puzzles without losing difficulty balance.

What’s unique: • 2,500 handcrafted levels across multiple grid sizes • Deterministic logic — no guessing required • A rule system inspired by constraint-solving and path-finding concepts • Daily challenges and global progress tracking • Fully built as a solo dev project

Technical notes for those curious: • Level generation tools I wrote validate solvability using a custom constraint solver • Difficulty is estimated via step-count of the solver • The game is optimized to run smoothly on low-end devices • Designed first for iOS, now fully adapted for iPad as well

I’d love feedback from puzzle lovers, game designers, and anyone interested in handcrafted logic design. Here’s the App Store link: [inserați linkul]

Thanks for reading — happy to answer any technical questions!

I've been having fun building out a really simple chess learning app for my daughter (7). It started with just "maze like" puzzles [1] and I've added a few more.

This "radioactive pooping knights" idea came from an Irish primary school chess website [2]. Really simple idea, two knights moving around the board leaving poo behind... Don't be the one forced to step on it.

best played with sound on.

[1]. https://minichessgames.com/#/movement/knight [2]. https://ficheall.ie/

highly subjective, may not be better for you to play with sound at all ;)

p.s. Any "buy me a coffee" goes to my daughter. Annoyingly they only pay out once you get above $10 USD and I think it's currently sitting at 9.85 or something!

I wrote this tool while debugging a driver because I couldn't find a tool that allowed me to open a file, seek randomly, and read and write.

I thought it might one day be useful to someone too.

Source code at https://codebuy.org/asset/69341f150b7587764a8a76aa

I've spent the last few weeks building SFX in Rust. It's a programming language experiment focused on context-oriented programming with some unusual design choices. Reality check first:

Solo project, 53 commits 1 GitHub star xD Zero users besides me No production usage Documentation is aspirational Many stdlib modules are minimal stubs

What actually works:

Basic interpreter (tree-walker) Arbitrary precision decimals (0.1 + 0.2 = 0.3) 1-based indexing (controversial, I know) Context/Situation system (the main idea) Some file I/O and basic networking JIT hooks exist but optimization is minimal

The Context idea (asking for feedback on this): Instead of checking if (user.isAdmin) everywhere, you define Situation: AdminMode that overrides methods:

Concept: User To GetPermissions: Return "read"

Situation: AdminMode Adjust User: To GetPermissions: Return "admin,write,delete"

Story: Create User Called Bob Switch on AdminMode Print Bob.GetPermissions # Now returns "admin,write,delete"

Objects change behavior based on active situations without mutating state. Is this useful or just overengineered? What's NOT ready:

Performance is terrible (haven't optimized anything) Standard lib is mostly TODOs AI features are vaporware REPL doesn't exist No tooling (LSP, debugger, etc.) Tests exist but coverage is poor

My questions:

Is context-oriented programming solving a real problem or creating busywork? Should I focus on making it fast OR making the stdlib useful? Is 1-based indexing a dealbreaker for you? Would arbitrary precision by default bother you for a general-purpose language?

I'm not trying to replace anything. This is a learning project that got out of hand. Repo: https://github.com/roriau0422/sfex-lang Pages: https://roriau0422.github.io/sfex-lang/ Honest feedback wanted - including "this is pointless, stop wasting time."

Hi, I’m Nathan, an aspiring engineer who likes to tinker with hardware. Earlier this year, I started making hardware/electronic projects through various Hack Club programs. It was perfect, but most, if not all, of my projects were being withheld due to high customs and import fees, so I wanted to change that.

Most of the price was actually assembling the PCB, and looking around the internet, I discovered the wonderful invention of the hotplate, and that I could make all of my PCBs myself for more than half the cost. Now, while I could have bought one on eBay, I decided to take up the challenge of making my own (because why not) and to make it as functionally portable as possible, so Ember was born.

I started reading how hotplates work and looked around the internet to see if anyone had made one, and I stumbled upon this repository (https://github.com/ikajdan/reflow-hot-plate). It was basically what I wanted to make, but reading through, I found that although it went up to 210 °C, the hotplate size was rather small. Also, it needed an external DC jack along with USB-C to be able to control/monitor it from a laptop.

Features/Specs:

- USB-C Power Delivery up to 100W (20V) using TI's TPS25730D

- STM32WB55CG microcontroller with Bluetooth support

- Large(ish) 120mm x 120mm flexible heatbed for big PCB reflow (JLCFH)

- Dual temperature sensing with MAX6675 thermocouple and PT1000 RTD

- OLED display with rotary encoder for easy control and preset management

- NFC support (because why not lol)

- Gate driver for precise PWM heatbed control

- Current and board temperature monitoring for safety

- 32MB Flash memory for graphics and data storage

- Portable design with custom acrylic / nylon case

If you want to see the complete journal of how I made it and all of the design decisions I made, you can check it out here: https://blueprint.hackclub.com/projects/1701

Here’s the GitHub repo for anyone interested in making their own: https://github.com/notaroomba/ember

Thanks to Hack Club’s Blueprint for sponsoring this project!

I’ve been working on a stateless compliance engine that validates IBAN/SWIFT, OFAC lists, ISO20022 (pain.001/pacs.008), and multi-chain data (ETH, BTC, XRPL, Polygon, Stellar, Hedera).

Statelessness feels important in financial and blockchain workflows because no user data persists between requests, outputs are fully deterministic, and auditors can reproduce results without relying on stored state.

Current progress: • Deterministic validators live and callable • On-chain checks working across 6 networks • ISO20022 structuring + downloadable PDFs • AWS backend deployed; Azure environment being added for multi-cloud isolation

Looking for technical critiques or alternative patterns for building stateless compliance systems.

Hi HN,

I have been working on an open source quantum computing SDK for the JVM called Quantum4J. I just launched the official site and wanted to share it here for feedback:

Website: https://quantum4j.com GitHub: https://github.com/quantum4j/quantum4j

What it is: A minimal quantum SDK written in Java Deterministic statevector simulator Strict OpenQASM 2.0 importer/exporter Pluggable backend design (example: IonQ REST API) JVM-first design so Java developers can build quantum workflows using familiar tooling

Why I built it Most quantum libraries are Python-centric and research-oriented; I wanted something that fits normal software engineering practices (builds, tests, CI/CD, Spring, etc).

Features Deterministic simulation (useful for testing + CI) QASM-based circuit interchange Clear, minimal API Real hardware backend example (IonQ) Examples included (Teleportation, Bell state, Grover, etc.)

Docs Full Javadoc published under /javadoc Examples included in the repo

Open to feedback

This started as a side project but it’s now getting more structure (examples, docs, hardware connector). I would love feedback from anyone doing quantum software, JVM work, hardware integration, or QASM tooling.

Thanks! Happy to answer questions.

No signup required—just upload or record a video to verify its truthfulness. You can test it on anyone: internet clips, your significant other, or even yourself.

I'm aware there are tons of scammy 'lie detector' apps out there, but I built this using SOTA multimodal models in hopes of creating a genuine breakthrough in the space. It analyzes micro-expressions, voice patterns, and context. In my own testing (over 50 trials), it reached about 85% accuracy, which honestly felt a bit scary.

It’s also fun to test on famous YouTube clips (like Obama talking about UFOs). I’d love to hear what you think and will be improving Watsn.ai every day based on your feedback!

Based on the much loved xkcd #1205, and useful for convincing someone that AI tool is worth it or that task should be automated.

If you spend 5 mins/day on something, it might be worth spending $87/month on a subscription to automate it for you!

I write a lot of long-form content and the same problem kept slowing me down. Writing was fine, but turning it into a clean, consistent PDF always took more effort than the content itself. I kept fighting with margins, spacing, headers, templates, exports, and it became the part of the process I dreaded most. I eventually stopped trying to force tools that weren’t built for this and started experimenting with a different approach: describe the structure in JSON and generate the PDF with a layout engine. I built it originally as a personal workflow, not as a product, but other people around me had the same pain so I cleaned it up and put a demo online. It is still early and rough in places, but if anyone here writes ebooks, reports, guides, or technical documents, I would appreciate feedback on the idea, the rendering approach, or any pitfalls I might not be seeing. Live demo: https://ebookforge.app/

Hi! This is an experimental learning project I've been working on.

NANO.NOQ is a very small binary container format for AES-GCM keys. The entire implementation is inside a single HTML file using WebCrypto (no backend, no external dependencies).

The .noq file format is simple: - header (“NOQ1”) - key length (2 bytes) - raw AES-256-GCM key - a 4-byte integrity slice (from SHA-256(key)) - 32 bytes of random padding

The project does NOT add new cryptography on top of AES-GCM. It's purely an experiment in designing a file format for storing keys separately from ciphertext without copy/paste.

There's also a mutation step for Base64URL ciphertext, but it is obfuscation only and not meant as a security layer.

I’m not a professional programmer — I built this with AI assistance as a way to learn about key storage formats, integrity fields, and browser-based crypto workflows.

Feedback, corrections, and criticism are very welcome.

Hello everyone,

I’m Karan — officially a Frontend Developer, but honestly, I relate more to being a Design Engineer because crafting beautiful interfaces is what I love most.

When I began my coding journey, frontend instantly hooked me. I stuck with it because it felt like the perfect blend of logic and creativity. However, over time, I noticed something interesting: many of my developer friends dreaded writing CSS. Building clean, polished UIs takes time, patience, and a ridiculous amount of pixel-perfect tweaking.

Yet, those same friends still wanted their projects to feel premium — smooth animations, modern layouts, and a top-tier user experience.

That got me thinking…

“What if anyone could drop stunning animated components into their site — without needing deep CSS knowledge?”

Fast forward six months of late nights, trial and error, and way too much caffeine… and that idea became ogBlocks.

ogBlocks is an Animated UI Library for React, packed with components that look premium and feel production-ready right out of the box.

You’ll find navbars, modals, buttons, feature sections, text animations, carousels, and tons more — all designed to instantly level up your UI.

I know you'll love it, just check it out

Best Karan

Hi HN,

I'm the creator of Manifesto AI.

I've noticed that while LLMs are getting smarter, their ability to interact with complex Web UIs is still fragile. Agents usually have to "guess" DOM selectors or rely on vision, which leads to hallucinations and broken workflows.

I realized that for AI to be useful in SaaS/B2B software, we don't need "Generative UI" (Text-to-App); we need a deterministic "State Layer" that agents can understand and control directly.

So I built Manifesto. It's a schema-first UI engine where:

1. You define the form/UI as a JSON Schema.

2. The engine renders it (React/Vue).

3. Crucially, it exports a "Semantic Snapshot" to the AI Agent.

Instead of parsing pixels, the Agent receives a clean JSON state (values, validation rules, available actions) and dispatches "Intents" (e.g., `setValue`, `submit`) to the engine.

Disclaimer: I built the core engine and this demo in just 4 days. It is currently in a very early Alpha (v0.1) stage.

I’m sharing this early because I want to validate if this "Intent-to-State" architecture makes sense to other developers.

I'd love to hear your feedback on the approach. Roast my code or the concept!

Demo: https://playground.manifesto-ai.dev

Repo: https://github.com/manifesto-ai/core

Tool which parses your SQL into AST and builds full JVM pipeline using Clojure.

Hey,

My name is Benjamin and as many developers, I was tired to not succeed my technical interviews, for any reasons.

I made SharpSkill in order to change that.

Real Use Case, flashcards & interview simulators.

One goal : Destroy the next technical interviews.

Open to any feedbacks.

I noticed that if I take >5 minutes to read and/or understand claude's response, Anthropic's prompt cache expires. The next message forces a full context rebuild, which costs ~1.25x (write) vs ~0.1x (read) and hits rate limits faster.

So I updated Grov, my open source tool to include a "heartbeat" mode, (--extended-cache) that sends a minimal token (just a .) every 4 minutes during idle time.

We also just shipped a Cloud Sync feature so your agent learns from your teammates' sessions (shared reasoning traces), but the cache keep-alive is the main "hack" in this release. It currently works only for claude code CLI.

Code is Apache 2.0. Let me know what you think of the proxy implementation.

I have been having a lot of fun getting GPT-OSS-20b (at temp=2.0, Top K = 100) to generate newspaper articles for local newspapers, then asking it to generate the content of articles I want to read.

The natural extension seemed like taking this extremely seriously, so this was a fun & quick Saturday morning project. I'm having a lot of fun clicking around and thought I'd share, in case anyone wants to know what is going on in Port Augusta.

I created Megafrost because I didn't want to continue paying extortionate prices to keep a backup of my images and videos. For instance, Google Drive charges $20/year for 100GB but that is way more than what it actually costs. Google Cloud offers cheaper storage to businesses: Archive Storage costs $1.44/year for 100GB!

So I just made an Android app that wraps that Archive Storage and integrates with Google Pay. The complexity of Google Cloud is gone and any person can now take advantage of its low pricing.

The only catch is that once you need to restore any image or video, you have to pay for that separatelly. This is because Google Cloud charges for downloading traffic (not for uploading). But it's not really a problem because the gallery of the average user fits in the storage of a modern phones so you will only have to restore in case of disaster.

What are your thoughts? Would you be happy with this pricing model?