Show stories

I started an experiment to let a WASM-powered webapp interact with a local git repo and see how well this works. It turns out, it works pretty well!

I made it into a "git wrapped" tool that shows you when you committed the most, and what languages and files you most touched.

Despite the scary prompt when you use the filesystem API everything happens locally and your code stays private. (You can of course also just try it on cloned public github repos).

Let me know what you think!

Hi HN,

Up to the middle of 2025, I was the CEO/CTO of a startup called Textualize. Somehow I had managed to land seed funding for my Python libraries for fancy terminal output. We wrapped up after three years because the funding ran dry.

I honestly thought I was sick of coding at that point. But it turns out I was sick of the stress and working all hours. A few weeks rest was all I needed.

It was about that time that coding agents exploded, and I could no longer ignore them. I wasn't impressed with the UI these tools offered. Having worked in the terminal for a few years, I knew you could get a better user experience. And so this project was born.

I had planned to create some kind of layer between the agent's SDK and the front-end. Fortunately after I started building this, Zed Industries released Agent Client Protocol (https://agentclientprotocol.com/). Which was precisely what I needed.

I've just released the code (It was a private repo for a while). Toad (a play on Textual Code) can run a large number of AI agents, which a nicer terminal UI.

Think of it as a "bring your own agent" coding CLI. Use whatever agent you want. I'm not trying to sell you tokens.

Ask me anything. I'll be hanging around for a while, if this post takes off.

Hi HN, We are the OpenDCAI group from Peking University. We built Paper2Any, an open-source tool designed to automate the "Paper to Slides" workflow based on our DataFlow-Agent framework. The Problem: Writing papers is hard, but creating professional architecture diagrams and slides (PPTs) is often more tedious. Most AI tools just generate static images (PNGs) that are impossible to tweak for final publication. The Solution: Paper2Any takes a PDF, text, or sketch as input, understands the research logic, and generates fully editable PPTX (PowerPoint) files and SVGs. We prioritize flexibility and fidelity—allowing you to specify page ranges, switch visual styles, and preserve original assets. How it works: 1. Multimodal Reading: Extracts text and visual elements from the paper. You can now specify page ranges (e.g., Method section only) to focus the context and reduce token usage. 2. Content Understanding: Identifies core contributions and structural logic. 3. PPT Generation: Instead of generating one flat image, it generates independent elements (blocks, arrows, text) with selectable visual styles and organizes them into a slide layout. Links: - Demo: http://dcai-paper2any.cpolar.top/ - Code (DataFlow-Agent): https://github.com/OpenDCAI/DataFlow-Agent We'd love to hear your feedback on the generation quality and the agent workflow!

I’ve been working on MiraTTS, a fine-tune of Spark-TTS designed for high realism and stable text-to-speech. The goal was to create an incredibly fast but high quality model.

Most open TTS models are either computationally heavy or generate 16-24kHz audio. Mira achieves high fidelity and speed by combining two things:

FlashSR: For generating crisp and clearer 48kHz audio outputs.

LMDeploy: Heavily optimized inference allowing for 100x real-time speed and low latency (roughly150ms).

I built this so local users have access to a high quality local text-to-speech model that works for any usecase. It’s currently in its early stages, and I'm currently experimenting with multilingual versions and multi-speaker versions. Streaming is coming soon as well.

Repo: https://github.com/ysharma3501/MiraTTS

Model: https://huggingface.co/YatharthS/MiraTTS

I also wrote a breakdown on how these LLM based TTS models work: https://huggingface.co/blog/YatharthS/llm-tts-models

Everyone's shipping AI tools right now, and here I am with a visual editor. Still, I think many teams are very familiar with the problem of "marketing wants to change the landing page again."

I've run into this for years. Campaign pages come in, engineers get pulled in, and tickets stack up. It's usually the same components, just rearranged.

A few years ago, at a startup I worked at, we built an internal tool to deal with this. You register your existing React components, they show up as drag-and-drop blocks, and the result is a JSX string. No schema to learn, no changes to your component code.

We used it in production, handling real traffic in a messy, legacy-heavy environment. It held up well. Over time, it powered roughly 60% of our traffic. Marketing shipped pages without filing tickets, and product teams ran layout-level A/B tests. That experience eventually led me to clean it up and open-source it.

Composify sits somewhere between a no-code page builder and a headless CMS. Page builders like Wix or Squarespace offer drag-and-drop, but lock you into their components. There are also solid tools like Builder.io, Puck, and Storyblok, but many require you to adapt your components to their model. Composify is intentionally minimal: it lets you use your actual production components as they are.

It's still early. The docs need work, and there are rough edges. But it's running in production and has solved a real problem for us. If you already have a component library and want non-devs to compose pages from it, it might be useful.

Homepage: https://composify.js.org

Happy to answer questions or hear feedback!

Hey HN! We built DNS Directory (https://dnsdirectory.com), a free, searchable database of public DNS servers with live monitoring every 10 minutes.

We needed to find an up-to-date list of DNS servers used by carriers around the world for a proxy fingerprinting / web-scraping project but we were shocked to find that it didn’t exist so we built it ourselves in an internal Hackathon

We’re adding more features but so far we:

Test 77K+ servers every ~10 minutes Allow filtering by uptime, location, security features (ad blocking, malware protection, DNSSEC) Show info on IPv6 support, anycast, etc. Show all historical testing information

We have no plans to monetize the site and it will stay free so it can be used as a public resource.

I’d love to hear ways we can improve the site. It works but certain things like content filtering detection are rough around the edges, and we want to add test nodes in Asia + US for better coverage as right now we just test from Amsterdam.

If you want a DNS server that isn’t already on the website then you can add them via the form and if you’re a large org that has a bunch to add then you can email me at support@dnsdirectory.com and we’ll ingest them.

Cheers!

The article discusses the AI3 (Artificial Intelligence, Augmented Intelligence, and Autonomy) framework, which provides a structured approach to developing and deploying AI systems. The framework emphasizes the importance of aligning AI systems with human values and ensuring their safe and responsible implementation.

Well, I certainly tried. I had to, because it has a certain quirk inspired by "digital minimalism."

The quirk is that it only allows you to fetch new articles once per day (or X days).

Why? Let me explain...

I want my internet content to be like a boring newspaper. You get it in the morning, and you read the whole thing while sipping your morning coffee, and then you're done! No more new information for today. No pings, no alerts, peace, quiet, zen, etc.

But with that, I needed it to be able to fetch all articles from my hundreds of feeds in one sitting. This is where Zig and curl optimisations come in. I tried to do all the tricks in the book. If I missed something, let me know!

First off, I'm using curl multi for the network layer. The cool thing is it automatically does HTTP/2 multiplexing, which means if your feeds are hosted on the same CDN it reuses the same connection. I've got it configured to handle 50 connections total with up to 6 per host, which seems to be the sweet spot before servers start getting suspicious. Also, conditional GETs. If a feed hasn't changed since last time, the server just says "Not Modified" and we bail immediately.

While curl is downloading feeds, I wouldn't want CPU just being idle so the moment curl finishes downloading a single feed, it fires a callback that immediately throws the XML into a worker thread pool for parsing. The main thread keeps managing all the network stuff while worker threads are chewing through XML in parallel. Zig's memory model is perfect for this. Each feed gets its own ArenaAllocator, which is basically a playground where you can allocate strings during parsing, then when we're done, we just nuke the entire arena in one go.

For parsing itself, I'm using libexpat because it doesn't load the entire XML into memory like a DOM parser would. This matters because some podcast feeds especially are like 10MB+ of XML. So with smart truncation we download the first few X mb's (configurable), scan backwards to find the last complete item tag, cut it there, and parse just that. Keeps memory usage sane even when feed sizes get massive.

And for the UI I just pipe everything to the system's "less" command. You get vim navigation, searching, and paging for free. Plus I'm using OSC 8 hyperlinks, so you can actually click links to open them on your browser. Zero TUI framework needed. I've also included OPML import/export and feed groups as additional features.

The result: content from hundreds of RSS feeds retrieved in matter of seconds, and peace of mind for the rest of the day.

The code is open source and MIT licensed. If you have ideas on how to make it even faster or better, comment below. Feature requests and other suggestions are also welcome, here or GitHub.

OpenMemory is an open-source project that aims to develop a decentralized, privacy-focused memory storage and retrieval system. The project leverages blockchain technology and distributed storage to create a secure and censorship-resistant platform for storing and accessing personal data.

The article discusses a tool called the DPP Compliance Checker, which helps users assess their compliance with the European Union's Data Protection Regulation (GDPR). The tool analyzes a website's privacy and data processing practices, and provides a report with recommendations for improving compliance.

I built a Rust-powered Wavelet Matrix library for Python.

There were surprisingly few practical Wavelet Matrix implementations available for Python, so I implemented one with a focus on performance, usability, and typed APIs. It supports fast rank/select, top-k, quantile, range queries, and even dynamic updates.

Feedback welcome!

Hi HN,

I wanted a dashboard for my home that didn't glow in the dark or look like a computer screen. I built this using a Raspberry Pi Zero 2 W and a Waveshare 7.5" E-Ink display.

Instead of the common approach of running a headless browser and taking screenshots (which is slow and resource-heavy), I render the image directly using Python and Pillow (PIL). This brings the refresh time down significantly and runs smoothly on the Pi Zero.

I wrote a blog post about the build process, the hardware I used, and the code structure.

I also ended up writing a short book/guide for those who want a complete step-by-step walkthrough to build the exact same setup, which is linked in the post.

Happy to answer any questions you might have to build your own display!

Most products that touch PDFs or images quietly rebuild the same thing: a hacked-together “router” that picks which OCR/vision API to call, normalizes the responses, and prays the bill is sane at the end of the month.

DocsRouter is that layer as a product: one stable API that talks to multiple OCR engines and vision LLMs, lets you route per document based on cost/quality/latency, and gives you normalized outputs (text, tables, fields) so your app doesn’t care which provider was used.

It’s meant for teams doing serious stuff with documents: invoices/receipts, contracts, payroll, medical/admin forms, logistics docs, etc., who are either stuck on “the OCR we picked years ago” or are overwhelmed by the churn of new vision models.

Right now you get a REST API, simple SDKs (coming soon), a few pluggable backends (classic OCR + newer vision models), some basic routing policies, and a playground where you can upload a doc and compare outputs side by side.

I’d love feedback from HN on two things:

1- If you already juggle multiple OCR/vision providers, what does your homegrown router look like, and what would you need to trust an external one?

2 - Would you prefer this or use the LLM/OCR providers directly, with the possibility of changing the provider every so often?

Demo and docs are here: https://docsrouter.com

PlayMix.ai is an AI-powered platform that enables users to create and collaborate on multimedia content, including videos, images, and presentations. The platform offers a range of features, such as automatic video editing, voice synthesis, and multi-language support, to help users streamline their content creation workflows.

I built an idle/clicker game about the AI hype cycle, because I love following how AI develops and also love idle games. You start circa 2018 with a laptop and a transformer idea, training your first model. The game follows "real" AI history: Attention Is All You Need → GPT-1 → you get the idea.

Core loop: - Train models (click or auto) to improve quality - Serve users to earn money - Buy hardware: from a used GTX 1060 to Dyson Sphere compute arrays - Research to unlock bigger models - Balance energy/compute resources Built with SolidJS + TypeScript + Vite. ~90KB gzipped. No frameworks, no backend, runs entirely in the browser. Saves to localStorage. The progression takes ~2-3 hours to reach ASI if you're actively playing, longer if idle. Hardware scales from 1 compute/sec (laptop) to 100M compute/sec (Matrioshka Brain). I tried to capture the exponential feeling of the AI scaling laws - each era feels faster than the last, which mirrors the real industry, but I didn't want to get into politics, corp, and stuff like that at this moment.

Would love feedback on game balance and pacing. The late game might be too fast or too slow depending on your playstyle.

Hope nobody get too mad at this, remember it's a parody, just a clicker game. And yes, it was made with an agentic LLM (I refuse to say vibe coded).

I work mostly in the terminal but found myself constantly switching to bloated GUIs like SSMS only for the simple task of browsing tables and run queries. And I didn't find Existing SQL TUIs intuitive, having to read documentation to learn keybindings and CLI flags to connect. Given I had recently switched to linux, I found myself using vs code's sql database extension. Something was awfully wrong.

I wanted something like lazygit for databases – run it, connect, and query and frankly just make it enjoyable to access data.

  Sqlit is a keyboard-driven SQL TUI with:

  - Context-based keybindings (always visible)
  - Neovim-like interface with normal and insert mode for query editing
  - Browse databases, tables, views, stored procedures
  - Adapters for SQL Server, SQLite, PostgreSQL, Turso & more
  - SSH tunneling support
  - Themes (Tokyo Night, Nord, Gruvbox etc.)

  Inspired by lazygit, neovim and lazysql. Built with Python/Textual.

https://github.com/Maxteabag/sqlit

Hello Everyone,

My name is Karan, and I'm a Frontend Developer, but I feel like I'm more of a Design Engineer because of my love for creating UIs

When I started my development journey, I fell for frontend development and have been stuck with it ever since

But I noticed that many of my friends hated writing CSS because creating UIs is a very tedious and time-consuming process, and you have to be pixel-perfect

But at the same time, they also wanted their project to look premium with beautiful animations and a world-class user experience

That's when I thought

"What if anyone could integrate beautiful animated components into their website regardless of their CSS skills?"

And after six months of pain and restless nights, I finally built ogBlocks to solve this problem.

It is an Animated UI Library for React that contains all the cool animations that will make it look premium and production-grade

ogBlocks has navbars, modals, buttons, feature sections, text animations, carousels, and much more.

I know you'll love it

Best Karan

This interactive rent map of Berlin provides detailed information on average rental prices for different neighborhoods, allowing users to assess the cost of living and make informed decisions about where to live in the city.

got tired of paying $29–99/month for simple contact forms on landing pages and side projects (Typeform, Tally, etc.).So I built GitForms: an open-source contact form that stores submissions as GitHub Issues.How it works:Form runs on your Next.js 14 site (Tailwind + TypeScript) On submit → creates a new Issue in your repo via GitHub API You get instant email notifications from GitHub (free)

Zero ongoing costs:No database, no backend servers Deploy on Vercel/Netlify free tier in minutes Configurable via JSON (themes, text, multi-language)

Perfect for MVPs, landing pages, portfolios, or any low-volume use case.Repo: https://github.com/Luigigreco/gitforms License: CC-BY-NC-SA-4.0 (non-commercial only – fine for personal projects, not client work).Curious what HN thinks: would you use this? Any obvious improvements or edge cases I missed?Thanks!

This article provides an overview of a machine learning systems course, covering key topics such as data management, model training, deployment, and monitoring. It offers insights into the practical challenges and best practices for building and maintaining robust ML-powered applications.

I created this because sometimes I want more than rlwrap but less than emacs. icl aims to hit that middle sweet spot.

It's a terminal application with context-aware auto-complete, an interactive object inspector, auto-indentation, syntax colouring, persistent history, and much more. It uses sly to communicate with the child lisp process and aims to be compatible with any sly-supporting implementation. I hope others find it useful!

Hi HN,

I’m a C++ student and I’ve spent the last few months obsessing over concurrent data structures. I’m sharing daking::MPSC_queue, a header-only, lock-free, and unbounded MPSC queue designed to bridge the gap between linked-list flexibility and array-based throughput.

1. FACING THE CHALLENGE: THE "LINKED-LIST BOTTLENECK" In traditional MPSC linked-list queues, if multiple producers attempt to enqueue single elements at a high, uniform frequency, the resulting CAS contention causes severe Cache Line Bouncing. In these saturated uniform-load scenarios, throughput hits a physical "floor" that often underperforms compared to pre-allocated ring buffers.

2. ARCHITECTURAL SOLUTIONS FOR REAL-WORLD SCENARIOS Rather than focusing on average throughput under uniform load, this design targets two specific real-world challenges:

Scenario A: Non-Uniform Contention (Burst Resilience) In many systems, producers are mostly idle but burst occasionally. By facilitating a high-speed lifecycle where node chunks circulate from Consumer (Recycle) -> Global Stack -> Producer (Allocate) with strictly O(1) complexity, the queue can rapidly establish SPSClike performance during a burst, peaking at ~161M/s.

Scenario B: Bulk Contention Reduction The enqueue_bulk interface allows producers to pre-link an entire segment in private memory. This reduces the contention from N atomic operations down to a single atomic exchange. The larger the batch, the lower the contention.

3. IMPLICIT CHUNKING & RESOURCE LIFECYCLE Instead of fragmented allocations, memory is managed via a Page -> Chunk -> Node hierarchy.

Implicit Composition: Unlike chunked-arrays, nodes are not stored in contiguous arrays but are freely combined into logical "chunks." This maintains linked-list flexibility while gaining the management efficiency of blocks.

Zero-Cost Elasticity: The unbounded design eliminates backpressure stalls or data loss during traffic spikes, with heap allocation frequency reduced to log(N).

4. ENGINEERING RIGOR * Safety: Fully audited with ThreadSanitizer (TSAN) and ASAN. * Type Safety: Supports non-default-constructible types; noexcept is automatically deduced. * Lightweight: Zero-dependency, header-only, and compatible with C++17/20.

A NOTE ON BENCHMARKS: In the interest of full transparency, I’ve benchmarked this against moodycamel::ConcurrentQueue. In highly uniform, small-grain contention scenarios, our implementation is slightly slower. However, daking::MPSC_queue provides a 3x-4x performance leap in non-uniform bursts and bulk-transfer scenarios where "Zero-Cost Elasticity" and contention reduction are the primary goals.

I’d love to hear your thoughts on this repository!

GitHub: https://github.com/dakingffo/MPSC_queue

I’m a former Systems Architect (Cisco/VMware) turned builder in Thailand. TheAuditor v2.0 is a complete architectural rewrite (800+ commits) of the prototype I posted three months ago.

The "A-ha" moment for me didn't come from a success; it came from a massive failure. I was trying to use AI to refactor a complex schema change (a foundation change from "Products" to "ProductsVariants"), and due to the scope of it, it failed spectacularly. I realized two things:

* Context Collapse: The AI couldn't keep enough files in its context window to understand the full scope of the refactor, so it started hallucinating, "fixing" superficial issues. If I kept pressing it, it would literally panic and make up problems "so it could fix them," which only resulted in the situation going into a death spiral. That’s the villain origin story of this tool. :D * Stale Knowledge: It kept trying to implement Node 16 patterns in a Node 22 project, or defaulting to obsolete libraries (like glob v7 instead of v11) because its training data was stale.

I realized that AI agents are phenomenal at outputting working code, but they have zero understanding of it. They optimize for "making it run at any cost"—often by introducing security holes or technical debt just to bypass an error. This is a funny paradox because when "cornered/forced" to use cutting-edge versions, syntax, and best practices, it has zero issue executing or coding it. However, it’s so hilariously unaware of its surroundings that it will do anything else unless explicitly babysat.

I built v2 to be the "Sanity Check" that solves a lot of these issues, and it aims to continue solving more of the same and similar issues I face. Instead of letting the AI guess, TheAuditor indexes the entire codebase into a local SQLite Graph Database. This gives the AI a queryable map of reality, allowing it to verify dependencies and imports without needing to load "all" files into context.

A/B Demo: https://www.youtube.com/watch?v=512uqMaZlTg As seen in the demo video, instead of trying to read 10+ full files and/or grepping to make up for the hallucinations, it can now run "aud explain" and get 500 lines of deterministic "facts only" information. It gets just what it needs to see versus reading 10+ files, trying to keep them in context, finding what it was looking for, and trying to remember why it was looking to begin with.

I also learned that regex/string/heuristics don't scale at all and are painfully slow (hours vs minutes). I tried the regex-based rules/parsers approach, but they kept failing silently on complex files and suffered constant limitations (the worst offender was having to read all files per set of rules). I scrapped that approach and built a "Triple-Entry Fidelity" system. Now, the tool acts like a ledger: the parser emits a manifest, the DB emits a receipt. If they don't match, the system crashes intentionally.

It’s no longer just a scanner; it’s a guardrail. In my daily workflow, I don't let the AI write a line of code until the AI (my choice just happens to be CC/Codex) has run a pre-investigation for whatever problem statement I'm facing at the moment. This ensures it's anchored in facts and not inference assumptions or, worse, hallucinations.

With that said, my tool isn't perfect. To support it all, I had to build a pseudo-compiler for Python/JS/TS, and that means preparing extractors for every framework, every syntax—everything, really. Sometimes I don't get it right, and sometimes I just won't have had enough time to build it out to support everything.

So, my recommendation is to integrate the tool WITH your AI agent of choice rather than seeing it as a tool for you, the human. I like to use the tool as a "confirm or deny," where the AI runs the tool, verifies in source code, and presents a pre-implementation audit. Based on that audit, I will create an "aud planning."

Some of the major milestones in v2.0

* Hybrid Taint: I extended the Oracle Labs IFDS research to track data flow across microservice boundaries (e.g., React fetch → Express middleware → Controller).

* Triple-Entry Fidelity: This works across every layer (Indexer -> Extractor -> Parser -> Storage). Every step has fidelity checks working in unison. If there is silent data loss anywhere in the pipeline, the tool crashes intentionally.

* Graph DB: Moved from file-based parsing to a SQLite Graph Database to handle complex relationships that regex missed.

* Scope: Added support for Rust, Go, Bash, AWS CDK, and Terraform (v1 was Python/JS only).

* Agent Capabilities: Added Planning and Refactor engines, allowing AI agents to not just scan code but safely plan and execute architectural changes

Hello HN,

I basically don't use notifications for anything. The noise is too much. Slack is too loud. Email is too slow. But sometimes you do need a note in your face.

I found myself missing 1990s pagers. I wanted a digital equivalent - something that does one thing: beep until I ack it.

So I built UDP-7777.

Concept:

- 0% Cloud: It listens on UDP Port 7777. No accounts, no central servers. You don't need Tailscale/ZeroTier/WG/etc, it's just easy for device sets.

- CAPCODES: It maps your IP address (LAN or Tailscale) to a retro 10-digit "CAPCODE" that looks like a phone number (e.g., (213) 070-6433 for loopback).

- Minimalism: Bare-bones interface. Just a box, a few buttons, and a big red blinker.

The Tech:

It's a single binary written in Go (using Fyne). It implements "burst fire" UDP (sending packets 3x) to ensure delivery without the handshake overhead of TCP.

New in v2.2.7:

- Frequency Tuning: Bind specifically to your Tailscale/ZeroTier interface.

- Squelch: Optional shared-secret keys to ignore unauthorized packets.

- Heartbeat: Visual/Audio alerts that persist until you physically click ACK.

I built this for anyone looking to cut through the noise—DevOps teams handing off the "on-call IP", or deep-work focus where you only want interruptions from a high-trust circle.

I'd love to hear your thoughts on the IP-to-Phone-Number mapping logic (it's purely visual, but I'm really into it).

Site & Binaries (Signed for Mac/Win): https://udp7777.com

This article discusses the development of a new manufacturing execution system (MES) to replace outdated legacy systems. The proposed solution aims to provide a more flexible, scalable, and user-friendly platform for manufacturing operations management.

Hi HN,

I built the first version of Drawize back in late 2016 specifically for a Samsung Tizen OS app contest. I crunched and built the whole thing (including the real-time multiplayer engine) in under 4 weeks.

It didn’t win anything in the contest.

Since it was built with web tech anyway, I published it on the open web in early 2017 just to see what would happen. It started living its own life, and today — 8 years later — the database processed the 100,000,000th drawing.

On the busiest days it’s been 30k+ active users, and storing 100M drawings currently sits at ~3.16 TB.

The milestone moment: I was watching live logs today, terrified the 100Mth drawing would be NSFW. Luckily, the RNG gods smiled and it turned out to be a Red Balloon (You can see the 100Mth drawing here: https://www.drawize.com/blog/100-million-drawings-milestone)

Tech stack (boring but fast):

Backend: .NET + WebSockets (real-time sync)

Frontend: hand-coded HTML/JS + jQuery (no React, no bundlers)

Data: PostgreSQL & MongoDB

Storage: Wasabi Cloud (moved there to save on S3 costs)

Scaling as a solo dev: real-time lobbies + reconnection edge cases + moderation/content filtering. I use content classification models trained in 2021 to filter bad content, and the real-time multiplayer side is mostly highly optimized .NET code.

Happy to answer questions about the “failed” Tizen origin, real-time multiplayer on the web, moderation, or how .NET handles the load.

Introducing Open-Schematics: a large public dataset of electronic schematics with rendered images and structured metadata for ML, circuit understanding, retrieval, and validation.

Hello HN. Here's the TLDR from the linked blog post: After running into context window issues on my first two projects, I developed a tool for making Claude Code use fewer tokens by creating an indexer that provides context in the search results. Built with sqlite and tree-sitter, it currently supports the following languages: C, Go, PHP, Python, and TypeScript. Get the code here: https://github.com/ebcode/SourceMinder

Happy to answer any questions about it here, and open to critical feedback. Thanks!