emadda

Hello HN,

This is a simple web app for creating basic paper based plans using A4 paper.

A short write up: https://madebyenzo.com/#a4list

Hello HN,

This is a simple web app to test the Microsoft AI 2 transcription model.

It is quite interesting because it is both fast and highly accurate.

Hello HN,

This is a macOS app for offline transcribing.

You can use the new Apple Speech APIs or Whisper.

It has a batch queue interface, so you can watch many input sources, including external drives.

It is completely sandboxed in the App Store, so it is isolated from your system and can only read the files you explicitly give it access to.

It stores its transcription data in plain files, so they can be read without the app on any machine.

Hope you find it useful. Thanks, Enzo.

Hello HN.

This is an experiment of creating a simple progressive web app (can be installed as a mobile app) to test Microsoft's new MAI 1.5 transcription model.

The standout features of the MAI model are accuracy and speed.

The app converts your speech into plain text lists.

No sign up required.

I like the technical design of WASM, but I feel that better OS sandboxes for regular native code will be the common approach to running untrusted code.

As soon as you compile to WASM you no longer have the C FFI and the ability to call the OS systems interfaces for files, network and others.

It is extra work to move something to WASM vs just compiling it and running it in a sandbox.

I think this comes down to higher competition and practice in Europe.

A football is the default “toy” given to young lads, and you can play anywhere with anyone.

So much so there are custom “no ball games” signs in many neighbourhoods due to noise averse residents getting annoyed.

There are also many supporting elders who try to improve and guide skill development.

Thanks.

It is using Gemini Flash 3 at the moment.

There is a lot to learn in nutrition. The glycemic load metric is quite revealing for pizza vs pasta (slow digesting carbs are supposed to be better). Al-dente cooked pasta is also slower digesting than well cooked pasta.

Another interesting thing is how each plant food has unique molecules that can be health promoting in humans. That was one aspect I wanted to reveal/compare for the foods I ate.

Dr Weil / Perfect Health Diet / Marks Daily Apple are three sources I like to check for information on nutrition.

Related: I created an app to track the molecules in your foods:

https://kg.enzom.dev/

You specify your foods in grams with plaintext (no pictures).

I never liked the "take a picture to measure calories" approach, as you could have 10 table spoons of olive oil which would drastically change the calories but would not show in a picture.

esbuild has been very stable for my projects too.

I think it is the only tool in the JS ecosystem that has not broken after a few years.

PKCE protects the auth token from interception by making it so that only your code that started the flow can redeem it by proving they have the secret code_verifier on the redeem_token() call.

The code_challenge == sha256(code_verifier). You will share the code_challenge at the start of the flow.

I just watched this, it is very good.

Yes, that is true, I was assuming that any LLM code was going to be checked by the developer. Step 7 in the guide is "review your code and ensure the important logic commented in the example server is still present".

The LLM is only for converting the JS based example code into your language X and HTTP framework Y (instead of giving example code for every combination of X and Y).

The standard implementation is in a single file `http_server.ts`, which is around 200 lines of well commented code, with important logic commented (around 5 lines). The example code can be run locally with a few commands.

The repo also contains a sequence diagram [1], a description of the HTTP handlers needed [2], and a live demo [3] where you can see the request/responses.

Thanks for your feedback I have made this clearer in the readme.

- [1] https://github.com/emadda/passkeybot/tree/master?tab=readme-...

- [2] https://github.com/emadda/passkeybot/tree/master?tab=readme-...

- [3] https://demo.enzom.dev/

Related: I released a hosted sign in page for passkey auth today.

Take a look:

https://passkeybot.com

I built a macOS app that uses Ghostty and fzy to fuzzy search over Apple Note titles. It is working quite well for me.

https://github.com/emadda/hot-notes/

Maybe JS directly?

Cloudflare D1 has this, although you are limited to using JS workers to read/write it.

https://developers.cloudflare.com/d1/best-practices/read-rep...

I built a macOS app [1] (to fuzzy search Apple Notes) using Ghostty as a base so that I could use its fast rendering for large lists.

I think there is space for an Electron-like framework but for standalone terminal apps. Looking forward to using Ghostty as a library.

[1]: https://enzom.dev/hot-notes/

The local html file can read local resources via src=file_path attributes on html tags (img, audio, video, script etc).

But the src-included files must be in the same directory as the root html file (or a descendant directory)

I used this in my macOS app Pocket Log to output a local html audio log (https://enzom.dev).

> Instead you should focus on creating notes that you are likely to revisit or likely to share.

One interesting thing I have discovered: the interface matters just as much as the content.

The faster you can recall notes, the more useful you find them, which makes it more likely you will write more notes.

I also put answers in the titles of my notes which allows me to scan a list of previously solved issues. The combination of a vague yyyy-mm-dd.md title and just a file system UI makes recall harder.

I have a fuzzy search app for Apple Notes that has been working well for me:

https://github.com/emadda/hot-notes

I think the speed at which you can open previous notes matters.

If it takes you 1 minute of scrambling in a GUI to find a previous note, you are less likely to read previous notes.

And also less likely to write new ones as you know you’ll never visit it again.

I have an app built on the fzy CLI and Ghostty terminal for Apple Notes. It is working well for me:

https://github.com/emadda/hot-notes

Good point, apps are missing the docker layered file system to isolate container file writes.

> The thing macOS really painfully lacks is not ergonomic ways to run Linux VMs, but actual, native containers-- macOS containers

Linux container processes run on the host kernel with extra sandboxing. The container image is an easily sharable and runnable bundle.

macOS .app bundles are kind of like container images.

You can sign them to ensure they are not modified, and put them into the “registry” (App Store).

The Swift ABI ensures it will likely run against future macOS versions, like the Linux system APIs.

There is a sandbox system to restrict file and network access. Any started processes inherit the sandbox, like containers.

One thing missing is fine grained network rules though - I think the sandbox can just define “allow outbound/inbound”.

Obviously “.app”s are not exactly like container images , but they do cover many of the same features.

Could have called it quantumdoc

I created Hot Notes to fuzzy search my Apple Notes folders and titles, it is working quite well for me. I think it could work well for your nested folders.

https://github.com/emadda/hot-notes

Something I have experimented with for a few sites is using Bun JS with HTML in JS strings.

Bun has a —hot flag that regenerates static html on change.

IntelliJ IDE can detect a // language=html comment above strings which formats the html inside and does highlighting etc.

Just using vanilla JS functions instead of a template language lets you write any logic yourself instead of looking up the template languages way of doing it.

Sometimes using mmap for SQL queries can speed them up (if you want to avoid adding too many indexes or cannot modify the db).

Set this on the connection:

PRAGMA mmap_size=…

https://www.sqlite.org/mmap.html

I think this works as it removes data copying between the os and your process.

Your process reads data from the os to execute the query.

With mmap the data reads have less overhead, so a full table scan may be fast enough.

It is strange. That was how I created the original prototype (from the terminal).

But in order to get the "global keyboard shortcut brings the search window forward from any space" behavior, it needs to be its own app. Otherwise, it would interact strangely with your current terminal windows, as they all have the same bundle ID.

I also want it to be easily installable without any dependencies, and usable for all skill levels.

> explain bundling an entire terminal emulator for something this simple.

- The app takes 40MB disk space, and around 80MB RAM. So quite light.

- Ghostty is fast, and is needed to render the search result list quickly. It is much lighter than a whole browser engine (Electron apps).

- I wanted a single "drag and drop" install method for all skill levels.

- The app needs its own windows and bundle ID so that the global keyboard shortcut can focus the Hot Notes window without interacting with your other terminal windows.

> Not sure that bundling their licenses in a file within Contents/Resources/ is sufficient

You can also view the MIT and other licenses in the About menu.

Hello,

This allows you to search for and open your Apple Notes.

Matching is instant, so much faster than Spotlight or the built in Notes search.

I wrote a post about some of the technical aspects here: https://madebyenzo.com/#hot-notes

And the project page is here: https://hotmatcha.dev/hot-notes/

Thanks, Enzo

I wrote https://robata.app for getting an overview of my open windows a while back. Let me know of any changes you would suggest. Thanks.