Happy to answer questions — and feedback on the physics or the explanations is very welcome. This project might be totally inaccurate in terms of real physics, this is how i do understand this on my own - i'm happy to confront this with reality

Comments URL: https://news.ycombinator.com/item?id=48459837

Points: 146

# Comments: 36

What is a bit unique is: 1) we built it in Rust and 2) the website is a little odd. Its design is inspired by CLIs (e.g., fzf, broot, vim) instead of web apps, and as such, lacks some affordances that you might typically expect in favor of keyboard-driven instant navigations (we have the very ambitious goal of an FCP of 100ms). In case you're curious, here's how we we built it: https://gitdot.io/designs

We recognize that we're making some bold claims here and are also well aware that we have much to learn. Building software is still hard, and that's a fact we seem to relearn everyday.

But we wanted to share what we built so far nonetheless.

Cheers, thank y'all for reading, and till the next —paul & mikkel.

Comments URL: https://news.ycombinator.com/item?id=48447806

Points: 312

# Comments: 291

Comments URL: https://news.ycombinator.com/item?id=48445554

Points: 1131

# Comments: 205

I've been working on a simple OS for tinkering and running bare metal apps on vintage PCs.

Since I couldn't quite decide whether to target pure 16-bit, or slightly more capable 32-bit machines, I ended up with two separate versions:

- GentleOS/32 (https://github.com/luke8086/gentleos32) works on i386+, requires 4MB of RAM and VGA display supporting 640x480x16 mode or any 256-color VESA mode.

- GentleOS/16 (https://github.com/luke8086/gentleos) works on 80186+, requires less than 192KB of RAM and a CGA display supporting 320x200x4 mode.

You can find more details in the repos.

Comments URL: https://news.ycombinator.com/item?id=48435943

Points: 101

# Comments: 92

Lathe is an experiment in using LLMs to teach me something new, instead of doing the work for me. It generates a hands-on, source-backed tutorial for any technical topic you want to learn. Then you work through it yourself by reading and typing the code by hand (gasp) in a local UI built for exactly that.

It's a Go CLI plus LLM agent skills (Claude Code / Cursor / Codex). You prompt something like "/lathe build a 3D slicer in Erlang", run `lathe serve` to spin up a local webapp, and read it in your browser. Every tutorial comes with the things that have made self-learning a pleasant experience for me in the past:

- table of contents that follows along as you scroll - side-notes that nudge you to think - exercises for the reader - sources backing up the content that you can use to take you deeper

To help make up for the lack of human brainpower behind the tutorial, you can also ask questions about the content, have another LLM verify the tutorial actually compiles and runs, or extend it with another part (no more "Part 4 of 6" that hasn't seen an update since 2021).

I didn't build lathe to replace human-written tutorials. I built lathe because I _love_ human-written tutorials, but wanted to learn technical domains where no good human-written tutorial exists yet (building a 3D slicer from scratch, making embedded Zig approachable, etc). There's a longer story in the README about how I got started with programming through PSP homebrew tutorials, and why losing that to LLMs bugged me enough to build this.

I'm not here to sell you anything (there's nothing close to a VC-backed startup here :D). It's an LLM, and its output is usually good but not perfect by any means. So far, my experience is that because you're the one typing and actually engaged, you catch the weird stuff (and I'm finding that pushing back on it is its own kind of learning). And yes, it's vibecoded, because it's low scope, low risk, and scratching a personal itch. I run it on Claude Code + macOS personally, other setups should work but I haven't been able to verify them yet.

If you can find resources to learn something that was written by a human, read that first. But Lathe is here to fill in the gaps when that isn't the case, and I hope it serves as an example where LLMs can help us think better, rather than less.

Repo: https://github.com/devenjarvis/lathe

Would love your feedback if you decide to check it out!

Comments URL: https://news.ycombinator.com/item?id=48433756

Points: 392

# Comments: 72

The idea is pretty simple: agents don't need the full kubectl get -o yaml or any 10k-line dump to make decisions. So that lowfat sits in between, strips the noise, and passes through what matters. Here's my real report after 2 months of personal use:

  lowfat history --all

  lowfat plugin candidates
  ─────────────────────────────────────────────────────────

    #  command                    runs   avg raw      cost   savings  source    status  
    1  kubectl get                101x     14.4K      1.5M     93.9%  plugin    good    
    2  grep                       103x     13.5K      1.4M     96.2%  plugin    good    
    3  git diff                    81x       995     80.6K     57.9%  built-in  good    
    4  kubectl                     90x       485     43.6K     33.6%  plugin    good    
    5  docker                     127x      5.5K    693.6K     96.1%  built-in  good    
    6  ls                         489x       117     57.3K     56.2%  built-in  good    
    7  find                        30x     16.5K    495.0K     95.5%  plugin    good    
    8  git show                    63x       490     30.9K     38.0%  built-in  good    
    9  git                        177x       368     65.2K     76.1%  built-in  good    
   10  git log                     86x       556     47.8K     78.5%  built-in  good    
   11  kubectl logs                 5x      3.6K     17.8K     43.0%  plugin    good    
   12  git status                  86x       152     13.1K     58.0%  built-in  good    
   13  docker ps                   20x       467      9.3K     52.8%  plugin    good    
   14  kubectl describe             6x       656      3.9K      1.2%  plugin    weak    
   15  docker images                9x       940      8.5K     61.8%  built-in  good    
   16  k get                        2x      2.1K      4.2K     35.9%  plugin    good    
   17  terraform                   10x       395      3.9K     32.1%  plugin    good    
   18  git commit                  32x        77      2.5K      0.0%  built-in  weak    
   19  docker build                 8x       487      3.9K     37.6%  built-in  good    
   20  docker compose              22x       979     21.5K     89.4%  built-in  good    

  total: 4.4M raw → 4.1M saved (91.8%)

But, why not alternatives (https://github.com/zdk/lowfat#alternatives) ? The answers are: - My goal is to make the core lightweight but extensible via plugins i.e. not trying to bundle every command in the installed binary so that people own their output filters. - Customizable per usecase via plugin or filter pipelines as I am using my own toolset. - Customizable for non-public CLI tools, for example, some enterprise might have their interal CLI tools that public won't have access. - People should own their data. So the design is local-first, No telemetry forever. - I kinda love UNIX-style composible pipes, so lowfat-filter has implemented this style. - Be able to adjust aggressiveness of the filter, so we can control that we won't strip something the agent needed.

GitHub: https://github.com/zdk/lowfat

Anyway, if anyone is interested, feedbacks and questions are welcome!

Thanks!

Comments URL: https://news.ycombinator.com/item?id=48409955

Points: 156

# Comments: 78

You mark checkboxes for what you have on hand (ricotta, sour cream, kefir, buttermilk, yogurt, cottage cheese, lemon, cream of tartar, etc.) and it computes the best recipe based on targets for acid, fat, salt, sugar, and CO2.

My particular favorite are the yeast-raised lemon ricotta kefir pancakes - the best I've ever had.

The math is done in a small pure-ESM library: ingredient composition to component masses and acid moles, a stoichiometry layer, and a bisection solver for the target deficits.

I'm not a chemist, so if something is off, tell me and I will fix it!

Comments URL: https://news.ycombinator.com/item?id=48408854

Points: 334

# Comments: 135

We’re two engineers who previously built Gem (co-founder/CTO and first hire), and we spent the last year coding almost exclusively using Codex and Claude Code. It’s been a huge change to how we code, and it’s been exhilarating seeing the models keep getting better – but we eventually realized that developing on localhost was holding us back:

- Git worktrees are clunky to set up and use for parallelizing work - It’s 2026, but somehow everyone is still walking around with laptops cracked open or SSHing into mac minis in their garage so their agents don’t stop working. - Mobile is treated like an afterthought even though coding is just texting now We started hitting resource constraints when multiple parallel agents test their own work by running the full app locally. - We tried different products, but couldn’t find any that solved all of our pain points – so we pivoted and decided to just build the ADE we wanted for ourselves.

Boxes.dev is a desktop and mobile app that lets you run Claude Code, Codex (using your subscription!), and the full dev environment for whatever you’re building, all on remote compute. It’s similar to Conductor or the Codex desktop app, except everything is in the cloud.

We use coding agents to scan your local dev setup and port it to the cloud. Then every Claude Code/Codex thread starts from a snapshot of the full setup, with its own filesystem and compute. No more git worktrees, no more cracked-open laptops, and your coding agents can actually test their work end-to-end because they can run your full app in isolation.

We’ve mirrored the Claude Code and Codex UX to feel natural to power users, and also have a fully-featured mobile app (no handoffs or remote control), plus scheduled automations and a Slack integration.

We’re obviously biased, but we’ve been building boxes.dev with boxes.dev for months and it’s honestly been a gamechanger. It’s hard to go back once you realize how much localhost has been limiting you; based on early feedback from beta testers, we’re increasingly sure that cloud is the future of agentic coding.

We’d love for you to experience it yourselves! Would appreciate any feedback – and happy to answer any questions on this thread.

Comments URL: https://news.ycombinator.com/item?id=48399358

Points: 104

# Comments: 78

If you'd like to learn more, an independent interview was posted a couple of weeks ago [1], and the FAQ [2] has a lot of information as well.

For the source code sharing, we've talked with lawyers and are inclined to no longer require the NDA/NCC for privacy reasons shared with us before (signing requires identification), but instead use a source-available permissive license that doesn't allow competition, like PolyForm Shield [3] (we do still have about 6 months before finalising a decision, here).

This does come with a lot more risks for us (it's harder to track down if someone publishes the code or uses it against the license), but given we've already passed 100 monthly active accounts, we're feeling more confident it's an acceptable risk.

The plan is to give logged in accounts (who are 12 months old or more) a way to download a ZIP of the current code base that's in the server.

Obviously there's no easy way to prove that's the case, but we're open to ideas/suggestions if someone here has them.

[1]: https://theprivacydad.com/interview-with-the-engineer-of-uru...

[2]: https://uruky.com/faq

[3]: https://polyformproject.org/licenses/shield/1.0.0

Comments URL: https://news.ycombinator.com/item?id=48396004

Points: 235

# Comments: 238

Comments URL: https://news.ycombinator.com/item?id=48386129

Points: 135

# Comments: 29

Comments URL: https://news.ycombinator.com/item?id=48374552

Points: 263

# Comments: 34

This is an infinite canvas note-taking tool where notes are laid out in a non-Euclidean, hyperbolic geometric space. As you drag and navigate through the view, you’ll experience a unique fluid distortion that naturally leverages your brain's spatial memory.

I’ve been obsessed with the concept of space in HCI for years. Many modern UI patterns are essentially workarounds for the lack of screen real estate. While researching zoom-based UIs a while back, I stumbled upon old HCI papers that used the Poincaré disk model of the hyperbolic plane to organize data. It elegantly projects an infinite space into a finite disk, keeping everything contextually visible.

I wanted to build an experimental app around this concept years ago, but the non-Euclidean math was a significant roadblock. Recently, I decided to give it a shot with the help of LLMs. It turns out that LLMs can handle the mathematical heavy lifting quite well, specifically in designing the coordinate systems and optimization algorithms, provided that you guide them with a solid architectural design.

This is still an experimental demo, but I hope it leaves an impression. I’d love to know if you find this paradigm practical for organizing your thoughts.

Comments URL: https://news.ycombinator.com/item?id=48372138

Points: 188

# Comments: 33

Comments URL: https://news.ycombinator.com/item?id=48367723

Points: 295

# Comments: 88

Comments URL: https://news.ycombinator.com/item?id=48348429

Points: 129

# Comments: 40

Comments URL: https://news.ycombinator.com/item?id=48344327

Points: 215

# Comments: 56

I'm a cardiology patient (HFrEF). Slow breathing at resonance frequency is one of the few non-pharmacological interventions shown to improve cardiac vagal tone and baroreflex sensitivity (Bernardi et al., Circulation 2002; Lancet 1998). I wanted a frictionless daily habit tool — no app store, no account, no subscription, just open terminal and go.

Design constraints, all grounded in the clinical literature:

- No breath retention — Valsalva risk in cardiac patients

- No rapid breathing — minimum 8-second cycles

- Exhale ≤ 2x inhale — no evidence for extreme ratios

- Immediate exit, always — q or Ctrl+C restores the terminal even on crash

The README includes a resonance frequency measurement protocol for anyone with a chest-strap HRV monitor who wants to find their individual optimum instead of using the 6 bpm default.

macOS only (uses afplay for audio cues). MIT licensed.

pip install breathe-cli

or

brew tap marekkowalczyk/breathe && brew install breathe.

Comments URL: https://news.ycombinator.com/item?id=48340315

Points: 132

# Comments: 55

Comments URL: https://news.ycombinator.com/item?id=48339753

Points: 158

# Comments: 26

It uses UK government LIDAR data to reflect the actual skyline, so it knows whether there's a building or a hill blocking the sun.

Caveats: - Outside LIDAR coverage (most of Scotland and Wales) it falls back to a synthetic horizon (less accurate). - Trees and recent developments (post-2022 or so) may not be in the data, and some address placements could be off (geocoding via OSM).

Feedback on the shading model especially welcome.

Comments URL: https://news.ycombinator.com/item?id=48334949

Points: 126

# Comments: 44

I previously introduced an open source private home security camera in 2024, which uses OpenMLS for end-to-end encryption: https://news.ycombinator.com/item?id=42284412.

It was called Privastead then and it's now renamed to Secluso.

John Kaczman found my project from here and has been working on it with me over the last year and half. We've made a lot of improvements to the software, which we would like to share with you:

- You can now set this up on your Raspberry Pi in less than 5 minutes with no technical expertise using our easy-to-use GUI deploy tool. We've put together a comprehensive build-your-own guide that walks you through the required steps (you can find a link at the top of the repository README).

- We use a customized, minimal OS based on the Yocto project for the camera.

- Every part of our stack except for the iOS app has reproducible builds. This includes our Android app, camera/server binaries, deploy tool, and the aforementioned OS.

- We've re-designed our mobile app, which is now on the iOS App Store and Google Play store.

- We now support UnifiedPush for more privacy-preserving push notifications.

Looking forward to seeing what you all think!

Comments URL: https://news.ycombinator.com/item?id=48330192

Points: 137

# Comments: 28

Comments URL: https://news.ycombinator.com/item?id=48328184

Points: 204

# Comments: 18