2025年9月7日 の Show HN

Years ago I stumbled across a basic version of this concept and it stuck with me. I knew if I was ever going to take on such a project, it would need to be flawless, but without coding experience it was just another idea that would never happen. By the end of 2024, as AI coding tools exploded everywhere, I finally had a way to make it real.

I started from zero knowledge and spent months collaborating with AI agents as a learning experience. Every pixel and every function went through me. The AI translated what I asked for into code, but every decision was human. I didn't use existing OS frameworks because the goal was learning how basic coding languages worked while also developing my skills with AI collaboration. Apart from basic libraries like xp.css and paint.js, it's all original code.

The result is a fully functional Windows XP recreation running in your browser. Complete experience with sounds, animations, and working applications. Even works properly on mobile, which required rebuilding everything to maintain the authentic feel without becoming unusable on touchscreens.

This project taught me more about coding and AI collaboration than I ever expected. Would love to hear your thoughts on the execution and any feedback on the technical approach.

hey guys. the other day i was migrating hosting providers and i just needed something not too heavy and convenient to spin up my backups for awhile and realised there is almost nothing out there. kimchi hasn't been updated for years and cockpit is heavy. so here's something i came up with in a couple hours because of a sudden urge, nothing fancy just basic creation with cloud init, lifecycle management and image/storage, but it's modern-ish and it compiles to a 8.4mb binary inclusive of the embedded web UI, CLI and API, and only dep is libvirt.

After building several Tauri desktop apps, I kept hitting the same wall: there's no reliable way to access cameras across Windows, macOS, and Linux. Every project meant reinventing camera integration, dealing with platform-specific APIs, and debugging permission issues.

  So I built CrabCamera – a Tauri plugin that handles all the camera complexity for you.

  What it does:

  - One API, three platforms: Same Rust code works on Windows (DirectShow), macOS (AVFoundation), and Linux (V4L2)
  - Permission handling: Automatically requests camera permissions on each platform
  - Format conversion: Takes care of the messy bits between platform formats and what your app needs
  - Error handling: Proper Rust error types instead of mysterious crashes
  - Hot-plugging: Detects when cameras are connected/disconnected

  The problem it solves:

  Before CrabCamera, adding camera support to a Tauri app meant:
  1. Writing separate native code for each platform
  2. Managing three different permission systems
  3. Handling format conversions manually
  4. Debugging platform-specific edge cases
  5. Maintaining it all as OS APIs change

  Now it's just:
  use crabcamera::Camera;

  let camera = Camera::new()?;
  let frame = camera.capture_frame().await?;

  Why I built it:

  I was working on a plant monitoring app (botanica) that needed reliable camera access for time-lapse photography. Existing solutions were either abandoned, platform-specific, or required complex native
  bindings.

  The Tauri ecosystem is growing fast, but camera support was this obvious gap. Every desktop app eventually needs camera access – video calls, document scanning, AR features, security monitoring.

  Technical highlights:

  - Uses nokhwa for the heavy lifting but wraps it in Tauri-friendly APIs
  - Proper async/await support throughout
  - Memory-efficient streaming for video capture
  - Built-in image processing pipeline
  - Extensible plugin architecture

  What's next:

  - WebRTC integration for video calls
  - Built-in barcode/QR code scanning
  - Face detection hooks
  - Performance optimizations for 4K streams

  The crate is MIT licensed and available on crates.io. I'd love feedback from other Tauri developers who've wrestled with camera integration.

  Links:
  - Crates.io: https://crates.io/crates/crabcamera
  - GitHub: https://github.com/Michael-A-Kuykendall/crabcamera
  - Documentation: https://docs.rs/crabcamera

We're two college students building an XR(AR/VR) native Operating System with a custom kernel. We're also Open Source so feel free to check our GitHub Repository- https://github.com/manaskamal/XenevaOS .

The journey hasn't exactly been easy, we've been criticized by a lot saying that whatever we're doing is impractical and that we're too ambitious. Regardless, we've been committed to reach our goal.

Here to answer all questions and doubts. Answering one question beforehand because we know someone is going to ask it -

Q: Why use your own kernel/ Why don't you use Linux/ Why are you trying to reinvent the wheel?

A: Using our own kernel helps us get rid of the baggage of legacy codes, bring the most optimal performance on our target hardware (XR/AR/VR) and achieve more efficiency than what we would've achieved on an existing kernel.

We're not trying to reinvent the wheel, but just building Formula One racing tyres for it.

Hey HN! I’m Robert. I worked on [Percy’s SDKs/support from 2018–2022.](https://github.com/percy/cli/graphs/contributors) If you ever reached out to support or opened an issue, I probably helped you. Hopefully it was positive :) After a few years away, visual testing still felt stuck, so I'm building Vizzly.

The problem: Design handoffs kinda suck. Designers make beautiful specs, devs implement them, then everyone realizes the details got lost somewhere. Current visual testing tools catch broken CSS but miss the real issue - making sure what ships actually matches what was designed, functionally (like really in the browser/OS/etc).

What it is

- Visual testing + review where you send actual screenshots (not DOM re-renders). Can be _any_ image to review (PDFS!)

- Collaboration built-in: reviewer assignment, approvals, @mentions, screenshot-level threads.

- Baselines: automatic (Git-aware), manual (not Git-based), or hybrid.

- Team-based pricing; generous free plan for OSS; on-prem available.

What’s different

- Capture-first: use the pixels your app produced (no “but it doesn’t look like that on my machine/CI”).

- Local TDD + CI parity: run locally with instant feedback; same flow in CI.

- Custom properties to filter/slice reviews (component, viewport, theme, etc).

Try it quickly (Playwright example)

```

npm i -D @vizzly-testing/cli

export VIZZLY_TOKEN=your-token

# in your tests:

import { vizzlyScreenshot } from '@vizzly-testing/cli';

let img = await page.screenshot({ fullPage: true });

await vizzlyScreenshot('homepage-layout', img);

```

I would love feedback on everything! Rough edges you hit using the product/sdk, baseline expectations across branches, what you need for design/dev review to feel “done”, etc. Features like root cause analysis, an MCP, and more collab features are coming. But it's just me building :p

I'm a big fan of OSS, so the OSS plan is pretty generous (10 seats + 10 review seats (20 total), unlimited public projects, 75GB, 6 concurrent builds). If it's not generous enough for teams, I'm willing to up it!

This is my first time launching anything like this, I'm super keen on getting feedback and working any support or suggestions folks have. If anyone knew me from my support at Percy, I _really_ enjoy those conversations and opportunities to ship a fix or feature at the end of a chat. If Vizzly isn't it for your team, I wanna know why and what I can do to help you.

Backstory + screenshots from my intro blog post: https://robertdelu.ca/2025/09/07/vizzly-introduction

Built a blockchain where you mine blocks by accomplishing real-world goals instead of solving computational puzzles. AI verifies your achievements, peers review them, and successful ones become permanent blockchain records.

Demo: https://proof-of-awesome.app

How it works:

Submit achievements like "ran 5km today" or "learned a new song" with photo evidence AI validates achievement authenticity and difficulty Community peer review for quality control Accepted achievements earn you the right to mine the next block Earn AwesomeCoins as rewards, permanently recorded on-chain

Technical implementation:

React + MUI frontend with real-time updates via Socket.io Node.js + MongoDB backend with simplified blockchain data structure Deterministic phase transitions synchronized across network nodes Built-in achievement categories (fitness, gaming, lifestyle, general)

Why this matters: Traditional proof-of-work wastes energy on abstract math. This creates value through actual human accomplishment while maintaining blockchain security properties. Every block represents someone doing something genuinely awesome in the real world. No crypto speculation, no fees - just a permanent record of human achievement. GitHub: https://github.com/AmyangXYZ/proof-of-awesome

AI is arguably the greatest invention in modern human history. Humanity has always evolved in hockeystick curves, each major discovery unlocking an entirely new trajectory of progress.

But what does this mean for us, Humans ?

dive in for more info here⬇ https://www.mandar.cloud/blog.html?slug=the-world-after-3-5-...

I wanted to explore the idea described in the tweet by Paul Sztorc that Bitcoin transactions can be art, so I created https://transactionbitmap.com which operates on the principle that art can be found in unexpected places, including the mathematical patterns and data inherent in blockchain transactions.

Art is subjective, just like value is.

I built a small Rust CLI game called GitType.

It’s a typing practice tool that takes your own Git repository and turns the code inside into typing material. Instead of random words, you type through real functions, comments, and code you’ve written — making practice feel closer to real-world programming.

Features: - Works directly in the terminal (no GUI required) - Pulls text from any local Git repo - Tracks WPM and accuracy - Keeps a history of your past runs (so you can see progress over time) - Fun ranking titles based on your score

Source and install instructions: https://github.com/unhappychoice/gittype

Would love feedback from fellow devs — especially around the scoring system and ideas for new modes. :)

Today, I’m proud to announce my latest invention, an app that you cannot use.

Yes, in fact it makes your phone unusable too.

Introducing The Hardest Focus App: Pocket.

You can start focus only by physically putting the phone away

- In your pocket (when outdoors) - Face down (while working/studying) - Or just Lock it.

No buttons, Just real focus.

But, if you get distracted and check your phone - You get a 5 second warning to correct yourself.

If you do not comply, all that progress will be murdered ruthlessly with a cold indifference to your feelings.

And for when you're deeply possessed by the algorithms, just tap twice on the back of your phone to summon the focus gods. It instantly opens pocket, locks you out of the phone and starts focus session.

However, during focus if your phone is locked and your mom calls

You can answer it and tell her you're locked in. The pact is broken only when you unlock the device.

Pocket is built on a core belief that true focus can only be achieved with physical disengagement and punishing bad behavior to build discipline.

This is my strongly opinionated take on focus with the Hardest Focus App

Focus is not a game. Focus is deadly.

Every year more deaths can be attributed to accidents that happen due to lack of focus than any natural cause.

Hello everyone,

I am Sumit and I am building nocodo.com - https://github.com/brainless/nocodo. It is is a fairly ambitious project and I feel I would get some needed support from folks on HN. Here is what nocodo is becoming:

  - Use your own Linux machine or a cloud server (dev machine) to manage full lifecycle of building apps using Git, GitHub, cloud providers, CI, etc.
  - You will get integrated view of code changes (Git), issues/tasks (GitHub initially), CI (GitHub Actions initially)
  - Access test deployments direct to your computer if you generate binary or to server - DNS, DB managed for you
  - Team collaboration will become possible at the task/project level
  - `manager` daemon hosts API to connect from web/mobile interfaces to projects on the dev machine
  - `manager` runs any number of Claude Code, Gemini CLI, Qwen Code, Continue dev, etc. - your own API keys/Pro plans
  - `manager-web` app that connects to `manager`, allows sending prompts to any project, see status, etc.
  - `manager` will have API integrations to GitHub, GitLab, CI platforms, Cloudflare, and cloud providers
  - `manager` will check CI, manage DNS for test and live deployment
  - `manager` builds on my own set of contextual prompts to allow working on your projects (vibe coding): http://nododo.com/playbook
  - `manager-mobile` app(s) will come soon that allows same functionality as manager-web
  - `launcher` app will come soon that manages developer server on Scaleway, Digital Ocean, etc. using your API keys, SSH keys, etc.

The UI is becoming similar to what you expect from Bolt, RepltIt, Lovable, etc. Initially nocodo will support new projects only, Rust + Actix Web backend and Typescript + Solid JS + Tailwind web apps. SQLite for DB with LiteStream + S3 backups. CI pipelines will be added for you - all generated by coding agents. The aim is to enable non engineering teams to build full-stack apps.

If you go to https://github.com/brainless/nocodo/releases you can see I use this myself. I connect to my developer machine over SSH (this will be through manager soon), I talk to Claude Code, Claude edits code code, use GitHub based workflow, test binaries locally and continue building.

nocodo will be self-hosted and have no vendor lock-in, supporting multiple coding agents, cloud providers, etc. It will have authentication through nocodo.com if you enable that and it will be a small subscription (like USD 60 annual for 5 people team).

I am a solo founder and I have been chasing this for the last 2 years. nocodo.com is with me since 2013. I felt like sharing this since it is taking shape and also because I am running out of funds. I consult on the side to keep lights on, so if you like my work and have any work please message me on any network I am on.

Thank you so much, Sumit

In 2019, an academic paper by Gleason et al. found that only 0.1% of Twitter image posts had any form of image description (alt text) [1].

I wanted to see the analogous number for Bluesky today - my full blog post is here [2], but I found looking at the live stream was illuminating and fun too:

* Bluesky image posts are frequent enough to keep moving, but not so frequent that it's an unreadable blur.

* There's lots of bot content for things like ADS-B feeds (planes nearby), radio station "Now playing", and good old-fashioned affiliate link spam.

* There is a lot of detailed descriptions for sexual content. This was a surprise to me!

[1] https://dl.acm.org/doi/10.1145/3308558.3313605 [2] https://digitalseams.com/blog/image-descriptions-on-bluesky

- Plain-text markdown is easy to update and human/machine-readable

- Clever CSS styling and animated logo[1] make the HTML version stand out

- PDF version: simply generate by printing this page from the browser (optimized for printing)

- See how it was done: https://github.com/Leftium/leftium.com/tree/main/src/routes/...

[1]: https://logo.leftium.com

I like light transport simulations and I like getting a job. So I created a simulation of glass caustics for my portfolio page. Because simulating things is intensive for web/mobile, it pre-computes the caustics which it then saves as an atlas and displays to the user. Hope you like it and please let me know if I can improve it! :)

Chai

Hi HN, I run an affiliate site with hundreds of outbound links. Over time, these links break — products go out of stock, vendors change URLs, and sometimes media just disappears. I got tired of manually checking them, so I built check-my-links.com ...my first NextJS project.

It scans my site regularly and flags broken links, missing images, or redirects — so I can fix them before users (or SEO bots) notice.

It started as a tool for myself, but I figured others might find it useful too. Happy to answer questions or get feedback!

Why did I not use existing tools? - Google Search Console updates slowly - Sophisticated tools cost hundreds per month - Free tools are unreliable

Hi HN, these challenges are meant to be used with an app that I'm building, but they can be used independently as well.

The app facilitates language learning with Youtube videos by showing the transcript alongside the video, translations, exercises and more.

I struggle with finding the right videos and staying consistent with my language learning, so having a structured plan helps a lot.

The generation process can take a few minutes, since it goes through multiple steps to find suitable videos (query expansion -> retrieval -> filter -> analysis -> filter -> generation)

Here's an example of a simple 7 day SpongeBob challenge in Spanish that I created: https://lingolingo.app/challenge/shared/curriculum-c9f797fe

With new GPU infrastructure clouds popping up everyday, the need for a globally available, S3 compatible, performant, cloud-native Object Storage product has become significant. Customers can access their data cheaply, quickly and easily in any cloud when using ACS.

I find this lightweight confetti library after getting frustrated with heavy animation libraries that would bog down pages just to add some celebratory flair. Canvas Confetti is designed to be performant, accessible, and easy to use.

Key features: • Tiny footprint: Just 1KB gzipped, no dependencies • Performant: Uses canvas for smooth 60fps animations, optional web worker support • Accessible: Built-in reduced motion support (`disableForReducedMotion` option) • Flexible: Custom shapes via SVG paths, emoji confetti, color customization

What makes it different: Most animation libraries are overkill for simple effects. This focuses solely on confetti but does it really well.

Demo: https://catdad.github.io/canvas-confetti GitHub: https://github.com/catdad/canvas-confetti