Show stories

This article discusses a new technology called 'Unscreenshottable' that prevents users from taking screenshots of digital content, aiming to protect sensitive information and intellectual property.

I made an art project about stablecoins. Enjoy!

Hi friends, I'm really excited to introduce KSON, which just entered public beta!

Anywhere a human is reading or editing YAML/JSON/TOML, KSON may be used as a more effective interface on that data. If you are such a human, we invite you to participate in this beta.

tl;dr Check out the website [1], play with the online playground [2], install the library for your programming language [3], edit in your favorite editor [4], discuss and give feedback [5], contribute to the project [6].

(A personal note about this project: I love software. Machines made of words! Such a wonder. KSON itself, as a collection of words that both make a machine and explain that machine, is an expression of a lot ideas I feel really passionately about around software and our relationship to it. I've put a lot of love into trying to make that expression eloquent and reliable. I hope some of that comes through clearly, and I look forward to discussing this more over time with anyone who's interested)

One of the key things KSON wants to say is: let's keep everything that's great about YAML and JSON as "Configuration User Interfaces", and let's make those interfaces more toolable, robust, and fun. Here's some of the ways we do that:

- KSON is a verified superset of JSON, has native JSON Schema support, transpiles cleanly to YAML (with comments preserved!), and is likely available wherever you want it—current supported platforms: JS/TS, Python, Rust, JVM, and Kotlin Multiplatform.

- KSON is also widely available in developer tools, with support for VS Code, Jetbrains IDEs, and anywhere you can plug in an LSP.

- KSON is fully open source, licensed under Apache-2.0, and you are invited to meet its words and tinker with how they make its machine. A lot of care, craft, attention and joy went into making the KSON project understandable and approachable for developers. We hope to see you around.

PS. This is an HN-friendly version of the official announcement at <https://kson.org/docs/blog/2025/09/17/introducing-kson/>.

[1]: https://kson.org/

[2]: https://kson.org/playground/

[3]: https://kson.org/docs/install/#languages

[4]: https://kson.org/docs/install/#editor-support

[5]: https://kson-org.zulipchat.com/

[6]: https://github.com/kson-org/kson

Everything I drive by one of these new tech billboards, I always wanted to either fully read it but cannot focus, or want to take a photo of it and share but I cannot because I'm driving. So I want to curate them in a place to enjoy them later, and share with friends about how crazy SF is.

Hi HN,

I’ve been working on something I’d love to share: 47jobs (https://47jobs.com ) – a marketplace where you can hire AI agents to do tasks instead of human freelancers.

Why? I kept noticing that many tasks on Upwork/Fiverr—coding, content generation, data analysis, automation—can now be handled by AI in minutes, not hours. But there wasn’t a platform built around hiring AI directly.

So I built 47jobs:

100% AI agents doing the work (no humans in the loop).

Jobs get delivered 10x faster, at transparent prices.

You can “hire” an agent for coding, automation, research, etc.

I’d love your thoughts:

Does a pure AI-agent marketplace make sense?

What types of jobs would you want AI agents to handle first?

Any UX or trust issues you’d expect with this model?

This is an early version, and I’m here to learn from your feedback. Thanks!

I live in the South of France (Var region), where wildfires destroy our forests and endanger lives every summer. This project is my attempt to build a concrete, open-source tool to help firefighters.

The article provides an overview of the Probabilistic Graphical Models Crash Course (PGMCP), an open-source project aimed at teaching the fundamentals of probabilistic graphical models. It covers key concepts, algorithms, and hands-on examples to help users understand and apply these powerful modeling techniques.

New Zealand Members of Parliament are required to annually disclose their financial interests (shareholdings, directorships, consultancies, etc.) but this gets published annually as an unwieldy 80+ page PDF that's hard to search effectively.

I processed structured data out of the PDF and built a searchable interface: https://open-register-of-pecuniary-interests.joshmcarthur.co....

You can search across all MPs' disclosed interests by name, company, or interest type. For example, you can quickly find which MPs have interests in specific sectors or companies, filter by category or political party.

The data extraction was interesting - I found that a two-pass approach worked well with Gemini 2.5 Flash - one to pull out MP names and referenced page numbers, then I extracted the specific pages each MP appeared on and extracted structured data just from these pages.

The approach could work for similar transparency registers in other countries - most seem to publish open data as PDF, which technically ticks the box, but isn't the most accessible format to work with. Even within NZ, I'm planning to expand the data I process to previous years, as well as processing data for local and regional councils (who have the same legal requirement to publish financial interests of council members).

Open sourced at https://github.com/joshmcarthur/open-register-of-pecuniary-i....

Tech stack: Ruby on Rails, SQLite (FTS5), Tailwind/DaisyUI - keeping it lightweight since this is just a side project to make public data more accessible.

So, after years of abandoning Rust after the hello world stage, I finally decided to do something substantial. It started with simple line rendering, but I liked how it was progressing so I figured I could make a reasonably complete PSX style renderer and a game with it.

My only dependency is SDL2; I treat it as my "platform", so it handles windowing, input and audio. This means my Cargo.toml is as simple as:

[dependencies.sdl2] version = "0.35" default-features = false features = ["mixer"]

this pulls around 6-7 other dependencies.

I am doing actual true color 3D rendering (with Z buffer, transforming, lighting and rasterizing each triangle and so on, no special techniques or raycasting), the framebuffer is 320x180 (widescreen 320x240). SDL handles the hardware-accelerated final scaling to the display resolution (if available, for example in VMs it's sometimes not so it's pure software). I do my own physics, quaternion/matrix/vector math, TGA and OBJ loading.

Performance: I have not spent a lot of time on this really, but I am kind of satisfied: FPS ranges from [200-500] on a 2011 i5 Thinkpad to [70-80] on a 2005 Pentium laptop (this could barely run rustc...I had to jump through some hoops to make it work on 32 bit Linux), to [40-50] on a RaspberryPi 3B+. I don't have more modern hardware to test.

All of this is single threaded, no SIMD, no inline asm. Also, implementing interlaced rendering provided a +50% perf boost (and a nice effect).

The Pentium laptop has an ATI (yes) chip which is, maybe not surprisingly, supported perfectly by SDL.

Regarding Rust: I've barely touched the language. I am using it more as a "C with vec!s, borrow checker, pattern matching, error propagation, and traits". I love the syntax of the subset that I use; it's crystal clear, readable, ergonomic. Things like matches/ifs returning values are extremely useful for concise and productive code. However, pro/idiomatic code that I see around, looks unreadable to me. I've written all of the code from scratch on my own terms, so this was not a problem, but still... In any case, the ecosystem and tooling are amazing. All in all, an amazing development experience. I am a bit afraid to switch back to C++ for my next project.

Also, rustup/cargo made things a walk in the park while creating a deployment script that automates the whole process: after a commit, it scans source files for used assets and packages only those, copies dependencies (DLLs for Win), sets up build dependencies depending on the target, builds all 3 targets (Win10_64, Linux32, Linux64), bundles everything into separate zips and uploads them to my local server. I am doing this from a 64bit Lubuntu 18.04 virtual machine.

You can try the game and read all info about it on the linked itch.io page: https://totenarctanz.itch.io/a-scavenging-trip

All assets (audio/images/fonts) where also made by me for this project (you could guess from the low quality).

Development tools: Geany (on Linux), notepad++ (on Windows), both vanilla with no plugins, Blender, Gimp, REAPER.

Would love any feedback

Hi HN,

I built Small Transfers, a payments platform for SaaS / API makers who want to bill customers per request instead of pushing them into subscriptions or pre-buy packages.

*Why?*

  - Many customers hate subscriptions and/or want to use a service occasionally.
  - Traditional payment processors add a fixed fee to every charge, making charges below 1 USD impractical.
  - Stripe UBB tracks usage, but you still need to write your own auth, add spending limits, and each merchant charges cards separately (extra fees for customers).

  - Each merchant has a Small Transfers account linked to their Stripe account via Stripe Connect, which is used to transfer payouts to merchants.
  - Each customer has a Small Transfers account where we verify them using Google Sign-In, 3-D Secure, and Stripe Radar to minimise the chances of a customer not paying their balance.
  - Customers allow your service to identify and charge them via platform's own OAuth. This also removes the need for your service to implement its own auth. (Simple services don't even need their own database.)
  - Merchants call a simple REST API to authorize and capture a charge with a minimum amount of 0.000001 USD. Note that you can authorize more than you capture, allowing you to authorize the max amount your request might use, and then capture your actual cost plus margin (great for many use cases, e.g., AI).
  - The platform takes care of charging customers and sending payouts to merchants.
  - Merchants pay a flat 3% fee. Customers pay payment processing fees when they pay for their balance.

I've been dog-fooding the platform with my own service (https://unattach.com/) and would love your feedback, specifically:

  - The general approach and whether there is anything I should do differently.
  - Any concerns and how I could mitigate them.
  - Any other feedback.

Thank you for your time! Happy to answer questions here.

Hi HN, I'm Oskar, a solo indie Mac developer from Sweden. For those in the Mac community, you might know me from my other apps like Sensei and Trim Enabler.

For years, I've been frustrated by the lack of customisation of macOS. In particular the Lock Screen which supports animated wallpapers, but only ones provided by Apple. There's never been a way to add your own personal videos.

I decided to figure out how to solve this, and the result is Backdrop 2.0. Backdrop is my Live Wallpaper app for Mac, it can play video wallpapers on your desktop. And now it can play on your Lock Screen too.

The core technical challenge, as you can imagine, came from trying to do something that Apple otherwise does not allow. However, through extensive reverse engineering of the macOS wallpaper system, I figured out a way to provide Backdrop wallpapers to the system in a way that allows them to play on the lock screen, and even appear in a custom section in System Settings.

I'm here all day to answer any questions—especially about the reverse engineering process, the challenges of integrating with macOS, or the experience of being an indie Mac developer.

Would love to hear your thoughts and feedback.

For speech-to-text, large-language-model inference and text-to-speech I created three wrapper libraries in C/C++ (using Whisper.cpp, Llama.cpp and Piper).

Follow the URL to see an example that shows how to use these libraries for a speech-to-text, LLM inference, text-to-speech pipeline.

Windows and Linux are supported.

Hello everyone!

I’ve been building an Open Source Ecommerce framework for Angular called Daffodil. I think Daffodil is really cool because it allows you to connect to any arbitrary ecommerce platform. I’ve been hacking away at it slowly (for 7 years now) as I’ve had time and it's finally feeling “ready”. I would love feedback from anyone who’s spent any time in ecommerce (especially as a frontend developer).

For those who are not javascript ecosystem devs, here’s a demo of the concept: https://demo.daff.io/

For those who are familiar with Angular, you can just run the following from a new Angular app (use Angular 19, we’re working on support for Angular 20!) to get the exact same result as the demo above:

```bash ng add @daffodil/commerce ```

I’m trying to solve two distinct challenges:

First, I absolutely hate having to learn a new ecommerce platform. We have drivers for printers, mice, keyboards, microphones, and many other physical widgets in the operating system, why not have them for ecommerce software? It’s not that I hate the existing platforms, their UIs or APIs, it's that every platform repeats the same concepts and I always have to learn some new fangled way of doing the same thing. I’ve long desired for these platforms to act more like operating systems on the Web than like custom built software. Ideally, I would like to call them through a standard interface and forget about their existence beyond that.

Second, I’d like to keep it simple to start. I’d like to (on day 1) not have to set up any additional software beyond the core frontend stack (essentially yarn/npm + Angular). All too often, I’m forced to set up docker-compose, Kubernetes, pay for a SaaS, wait for IT at the merchant to get me access, or run a VM somewhere just to build some UI for an ecommerce platform that a company uses. More often than not, I just want to start up a little local http server and start writing.

I currently have support for Magento/MageOS/Adobe Commerce, I have partial support for Shopify and I recently wrote a product driver for Medusa - https://github.com/graycoreio/daffodil/pull/3939.

Finally, if you’re thinking “this isn’t performant, can’t you just do all of this with GraphQl on the server”, you’re exactly correct! That’s where I’d like to get to eventually, but that’s a “yet another tool” barrier to “getting started” that I’d like to be able to allow developers to do without for as long as I can in the development cycle. I’m shooting to eventually ship the same “driver” code that we run in the browser in a GraphQl server once all is said and done with just another driver (albeit much simpler than all the others) that uses the native GraphQl format.

Any suggestions for drivers and platforms are welcome, though I can’t promise I will implement them. :)

Hi HN!I built *pyproc* to let Go services call Python like a local function — *no CGO and no separate microservice*. It runs a pool of Python worker processes and talks over *Unix Domain Sockets* on the same host/pod, so you get low overhead, process isolation, and parallelism beyond the GIL.

*Why this exists*

* Keep your Go service, reuse Python/NumPy/pandas/PyTorch/scikit-learn. * Avoid network hops, service discovery, and ops burden of a separate Python service.

*Quick try (\~5 minutes)*

Go (app):

``` go get github.com/YuminosukeSato/pyproc@latest ```

Python (worker):

``` pip install pyproc-worker ```

Minimal worker (Python):

``` from pyproc_worker import expose, run_worker @expose def predict(req): return {"result": req["value"] * 2} if __name__ == "__main__": run_worker() ```

Call from Go:

``` import ( "context" "fmt" "github.com/YuminosukeSato/pyproc/pkg/pyproc" ) func main() { pool, _ := pyproc.NewPool(pyproc.PoolOptions{ Config: pyproc.PoolConfig{Workers: 4, MaxInFlight: 10}, WorkerConfig: pyproc.WorkerConfig{SocketPath: "/tmp/pyproc.sock", PythonExec: "python3", WorkerScript: "worker.py"}, }, nil) _ = pool.Start(context.Background()) defer pool.Shutdown(context.Background()) var out map[string]any _ = pool.Call(context.Background(), "predict", map[string]any{"value": 42}, &out) fmt.Println(out["result"]) // 84 } ```

*Scope / limits*

* Same-host/pod only (UDS). Linux/macOS supported; Windows named pipes not yet. * Best for request/response payloads ≲ \~100 KB JSON; GPU orchestration and cross-host serving are out of scope.

*Benchmarks (indicative)*

* Local M1, simple JSON: \~*45µs p50* and *\~200k req/s* with 8 workers. Your numbers will vary.

*What’s included*

* Pure Go client (no CGO), Python worker lib, pool, health checks, graceful restarts, and examples.

*Docs & code*

* README, design/ops/security docs, pkg.go.dev: [https://github.com/YuminosukeSato/pyproc](https://github.com/YuminosukeSato/pyproc)

*License*

* Apache-2.0. Current release: v0.2.x.

*Feedback welcome*

* API ergonomics, failure modes under load, and priorities for codecs/transports (e.g., Arrow IPC, gRPC-over-UDS).

---

Source for details: project README and docs. ([github.com][1])

[1]: https://github.com/YuminosukeSato/pyproc "GitHub - YuminosukeSato/pyproc: Call Python from Go without CGO or microservices - Unix domain socket based IPC for ML inference and data processin"

An install script to create a strong and stable blend of Omarchy on top of CachyOS. You must install CachyOS first (please read the README file.)

Feedback and contributions welcome!

TL;DR: dagger.js is a buildless, runtime-only micro-framework that plays nicely with native Web Components. It uses HTML-first directives (e.g. +click, +load) so you can ship a page by dropping a single <script> from a CDN—no bundlers, no compile step.

Why I built it Modern stacks are powerful but often heavy: bundlers, compile steps, framework DSLs, local CLIs. For internal tools, small apps, and edge/serverless deployments, I wanted something you can view-source, paste into a page, and ship.

What it is:

Runtime-only: no build or VDOM compile; hydrate behaviors directly on HTML. HTML directives: e.g. +click, lifecycle +load / +loaded / +unload / +unloaded. Zero APIs: dagger.js works in pure declarative mode, modules and directives provide everything you need to build your application. Web-Components-first: works alongside Custom Elements; keep concerns local. Distributed modules: load small, focused script modules via CDN. Progressive enhancement: the page renders without a build step.

Use cases:

Admin panels & dashboards that don’t warrant a full toolchain Embed widgets, docs-sites with interactive bits Edge/serverless apps where cold start and simplicity matter

Links

GitHub: https://github.com/dagger8224/dagger.js Docs/Guide: https://daggerjs.org Examples: https://codepen.io/dagger8224/pens

I’d love feedback on edge-cases, and where it breaks. Happy to answer tough questions here.

Hey all! I recently gave a workshop talk at PyCon Greece 2025 about building production-ready agent systems.

To check the workshop, I put together a demo repo: (I will add the slides too soon in my blog: https://www.petrostechchronicles.com/) https://github.com/Aherontas/Pycon_Greece_2025_Presentation_...

The idea was to show how multiple AI agents can collaborate using FastAPI + Pydantic-AI, with protocols like MCP (Model Context Protocol) and A2A (Agent-to-Agent) for safe communication and orchestration.

Features:

- Multiple agents running in containers

- MCP servers (Brave search, GitHub, filesystem, etc.) as tools

- A2A communication between services

- Minimal UI for experimentation for Tech Trend - repo analysis

I built this repo because most agent frameworks look great in isolated demos, but fall apart when you try to glue agents together into a real application. My goal was to help people experiment with these patterns and move closer to real-world use cases.

It’s not production-grade, but would love feedback, criticism, or war stories from anyone who’s tried building actual multi-agent systems. Big questions:

Do you think agent-to-agent protocols like MCP/A2A will stick?

Or will the future be mostly single powerful LLMs with plugin stacks?

Thanks — excited to hear what the HN crowd thinks!

The article discusses the Izumi Chibi-Py project, a Python framework that aims to provide a simplified and opinionated approach to building modern distributed systems, with a focus on developer productivity and operational simplicity.

The article introduces semlib, a Python library for semantic similarity and text analysis tasks. It provides a simple, efficient, and easy-to-use interface for working with various text similarity algorithms and can be used for applications such as text classification, recommendation systems, and content analysis.

Hi all!

A few things of note -- I want this to remain a freemium service, where a reasonable amount of scans / capabilities are free per month etc. This is a passion project for helping people get access to security tooling that don't have the time/budget/etc to manage their own infrastructure. At the same time, I am paying a lot out of pocket to make this work, so I have added a credit system for users to support the cause at large.

I don't have much $$$ for bounties, but I am willing to pay what I can. If you find a security issue on the site, please report it via the contact info on https://meldsecurity.com/security.txt

I've got a roadmap of security tools to add to the toolbox, such as Dependency Scanners (E.g Trivy), Log Analyzers, secrets scanners, etc. If there's something you'd like added to the toolbox, let me know!

Also if you need more credits after the sign up bonus, just open a support case and ask for it and I will add some to your account! (obviously purchasing a credits package is greatly appreciated ;))

Anyways, any feedback would be greatly appreciated!

An offline first audio deck station

Does need online access but can play offline.

HTML5 needed.

Load local files, up to 2 GB audio.

Smooth transition between tracks.

EQ.

Compressor, pitch and speed controls.

Uses tone.js

Hi HN!

I’ve always been a fan of application launchers, and I was impressed by the approach the Raycast team took — especially their extension system. About six months ago I started building something similar for Linux, aiming to integrate deeply at the OS level and give extensions a lot of power.

Vicinae is written in C++ with Qt Widgets. I chose Widgets over QML for more imperative control of the UI, especially around extension handling. So far that’s worked well — modern C++ is great.

To support my goals I built a number of custom widgets, including a fully virtualized list that can efficiently render tens of thousands of items. That gave me a lot of respect for Qt — it’s a powerful framework that mostly stayed out of my way.

A key feature is support for Raycast extensions (React + TypeScript), most of which can be installed and used directly inside the launcher (though not all features are implemented yet). There’s also a native API package (@vicinae/api) for writing Vicinae-specific extensions with additional capabilities. This required writing a custom React reconciler — surprisingly straightforward, though still unpolished.

Like Raycast, Vicinae ships with powerful built-in modules, but the goal isn’t to make a clone. I want it to grow into its own project that fits the FOSS model better, while staying compatible with the Raycast ecosystem. I also plan to bring it to other OSes eventually.

I’d love feedback on the technical approach, and suggestions for what would make this useful to you. Contributions are very welcome — I’ve already been pleasantly surprised by how quickly people started helping.

Docs: https://docs.vicinae.com Repo: https://github.com/vicinaehq/vicinae

I've been working on OrderlyID, a new identifier format for distributed systems.

It's like UUID/ULID/TypeID, but with a few twists:

- Typed: every ID has a human-readable prefix (order_xxx, user_xxx).

- K-sortable: lexicographic order ≈ creation time.

- Structured fields: 160-bit body includes time, tenant, shard, sequence, random.

- Checksums: optional 4-char integrity check to catch copy/paste errors.

- Privacy flag: can bucket timestamps for public-facing IDs.

Format:

<prefix>_<payload>[-<checksum>]

Example:

order_00myngy59c0003000dfk59mg3e36j3rr-9xgg

There's a draft spec with conformance tests:

https://github.com/kpiljoong/orderlyid/blob/main/spec/0001-s...

Go reference implementation and CLI:

https://github.com/kpiljoong/orderlyid

Compared to TypeID, OrderlyID adds larger bit size (160 vs 128), tenant/shard/sequence fields, optional checksum, and a privacy bucket flag.

Status: Draft v0.1 — stable enough for experimentation. Feedback and contributions very welcome.

Repo: https://github.com/kpiljoong/orderlyid

I hacked an AI background checker. After a week or two of nights & weekends with Cursor, React, Typescript, Supabase, Vercel, etc... the site is live.

Preview reports are redacted and full reports read a bit like Wikipedia pages for anyone.

The reports are quite fun. Try it out! If you or someone you know are interested in lots of reports, please feel free to reach out with a note about the use-case.

Cheers

I built Vatify, a lightweight API to take the pain out of EU VAT. With just three endpoints you can validate VAT IDs, fetch up-to-date rates, and calculate the correct VAT (including reverse charge logic).

Hey HN! This is a fun/educational project I built to learn OS programming. I started working on it right after graduating high school last year and have been working on it on and off during my first year of university. It features a TCP/IP stack, an HTTP server, a RAM file system, a BIOS bootloader, paging and memory management, and concurrent tasks based on cooperative scheduling, along with a custom library. It's written in a C programming style focused on safety (based on a custom library of core abstractions) that's inspired by the writing of Chris Wellons (nullprogram.com).

There is a link to a test deployment in the README. The TCP/IP implementation is nowhere near perfect, of course, so there may be issues loading the page. I'm curious how the system holds up if this post gets any attention ;-)

After two years of development, I'm super excited to release Beat Maker! This is my take on what I hope is the best free, web-based drum machine.

My goal was to build something that was not only fun and easy to use for beginners but also powerful enough for serious producers. I did extensive research on existing drum machines, analyzed their UX, and tried to build something that adds something new.

It's a nearly 100% client-side app, written in ClojureScript, and is a PWA so you can install it to your home screen for an app-like experience.

Besides the standard grid editor, Beat Maker has some unique features that I think HN readers might find interesting:

- Procedural sample generation. One annoying thing about writing beats is searching through folders full of samples. I wanted to improve this and so I added the ability to generate new samples with a single click, giving you an infinite supply of unique drum samples. * Generative beat creation. If you're looking for inspiration, Beat Maker can generate entire patterns for you as a starting point. You can then edit and tweak the beat to your liking. Great for solving the "blank canvas" problem and giving you something good to start from. * Advanced export options. This is where it really shines for producers. You can export your work as: * A standard WAV loop * Individual stems (ZIP) * A MIDI file * A ZIP file of all your samples as WAVs * A SoundFont (.sf2) drum kit from your generated samples * An Impulse Tracker (.it) file for use in trackers like Renoise, OpenMPT or a Polyend * Pocket Operator/Volca sync. It can output a sync signal on the left audio channel to sync with these hardware devices for perfect timing. * Per-Note FX. You can add effects like volume slides, repeats, and start volume changes to individual notes for more complex drum phrases incorporating flam and roll.

As an old school tracker guy, I'm particularly excited about the Impulse Tracker export mode. I was surprised to discover how many DAWs (including hardware like Polyend) can import this format. Of course, you can also pull up Impulse Tracker on DOSBox, or the more modern re-implementation, Schismtracker for that retro experience.

By the way, the beat generator feature is not trained on any artists or anything like that. It's an algorithm I built from scratch myself.

The audio engine is built on a declarative audio graph (using `virtual-audio-graph`), inspired by React's virtual DOM, which makes managing the Web Audio API much cleaner. If you're building web based audio apps I highly recommend checking out this library.

I'd love for you to try it out and let me know what you think. Feedback (and the inevitable bug reports) most welcome! Thank you!

P.S. Also, here's a video summary: https://youtu.be/qVmEn9z3H24

I often find myself trying to solve a geometry problem where the constraints are really simple to understand, but solving it algebraic is really hard and tedious.

I built this whole thing from scratch with Claude Code. It's my first time trying it and I literally did not write a single line of code...

That said, it still would be hard build this as a novice. I had to guide things along the happy path, but it saved me a ton of time!

The code is open source! Let me know if you run into any issues.