Kevin Lynagh

Have you considered pricing the first batch at EUR 4000 each? :)

To quote myself[0] from too long ago:

"Very rarely will someone tell you that you're not charging as much for something as you should (perhaps with the exception of patio11 because he wants us all to make more money :) ) but generally there's always someone who will say something costs too much."

Due to a number of factors (including some past experience with hardware development & a recognition that most people purchasing low volume hardware do not have a realistic perspective on the costs involved) one of my hobbies is suggesting low volume hardware developers consider increasing their prices in order to potentially create a more financially sustainable business over the long term. (An outcome which is both better for the developer & their customers.)

Of course, such suggestions cost me nothing (as I don't currently have the disposable income either way) and their worth can be valued at the price you paid for them. :)

(And if @jacquesm advises you otherwise, I'd advise ignoring me. :D )

On the other hand if you decide to increase the price by even EUR 100 and you still sell out the batch, well, "it's free real estate" as they say...

Anyway, the prototype unit you demo in the SOS video looks really slick, so, nice work. :)

In case it's helpful here is a link dump[1] of various hardware-related manufacturing/pricing resources I've collected over the years, in rough suggested reading priority order:

*…

Here's an example of the kind of thing I'm talking about, from the HN front page today:

"Why I rewrote my Rust keyboard firmware in Zig: consistency, mastery, and fun" https://kevinlynagh.com/rust-zig/

I apologize in advance if it seems like I'm moving the goalposts. You're right that implementing a C compiler isn't a common or trivial task. My point is that implementing a Rust compiler is a much more complex task.

> the vast, vast majority of C code is running on a handful of well supported architectures.

Irrelevant. How much C vs Rust (vs Zig or D or ...) is running on the long tail of hardware?

FWIW, if Rust displaces C on the lion's share of machines, that's great. I'm not against Rust, or in favor of C.

> these days a better question is something like how long it would take to implement an LLVM backend.

Yes, absolutely, I agree.

Ideally you would have a program that takes as input a machine description and emits as output a correct Rust (or C or Zig or D or ...) compiler for that machine.

Author here.

For more background on product development about Finda, there are notes on my personal website here: https://kevinlynagh.com/datatron/

I started this as a UI research project to try and replace OS X Finder with a keyboard-only UI. A strong inspiration was the Helm Emacs package.

My initial prototype was in ClojureScript/Electron, and I was exploring far more features like inline preview, and a command/argument (verb/noun?) builder system.

However, after showing my prototype to a few friends, they were all much more interested in the fast search and window switching capabilities, so I decided to cut scope, focus the project on those features, and get something out the door.

This is my first Rust project, and I've been thrilled with the language and that community in terms of great libraries, documentation, and their willingness to help beginners like myself.

p.s. Sorry I'm late to the party, I pushed this blog post online immediately before going to sleep for the night =P

Not very satisfying that he didn't actually design a flatpack bed.

There is an interesting optimization problem in this that the author didn't touch on: create a design that maximizes the useful material use.

So you might start with a design that is really spindly, and has too many joints. Then run that through the optimizer, so that you can see the proposed layout. This design will have lots of waste, but you will also be able to see where you could add strength or functionality by consuming the offcuts.

In the author's design[1], the overlaps can simply be cut out of the other members without reducing strength too much. The central portion can then be cut into cantilevered tables, and a few more offcuts can provide bracing or legs, which gives you free integrated nightstands (as wings off the existing bed).

[1] https://kevinlynagh.com/newsletter/2025_07_flatpack/cad_nesting.jpg

Definitely still mostly C. Although currently tossing up whether we use some very limited C++ for a new project: some templated types to handle memory safety, and some strict encapsulation.

I'm quite intrigued by Zig and am hoping to get in and play with it, since it aims to be a "better C" (not C++) so it remains a small language. See this recent post which triggered my curiosity: https://kevinlynagh.com/rust-zig/

(edit: more thoughts on Zig) I am intrigued because I want out of a new embedded programming language aligns perfectly with their approach. comptime instead of the C preprocessor, generics, any allocation is explicit (any memory allocation is at initialisation time), etc.

https://maxwelldulin.com/Resources - short summaries of highly technical security posts (4/wk)

https://portswigger.net/research - web security research from the geniuses at portswigger (1/wk)

https://googleprojectzero.blogspot.com/ - project zero's research (1/mo)

https://hn.invades.space/hn_gems_rss.xml - top links extracted from comments on top hn posts (85/wk)

https://kevinlynagh.com/ - posts regularly contain a great selection of links (1/mo)

http://www.paulgraham.com/ - classics (1/mo)

https://www.bellingcat.com/ - open source research (1/mo)

https://pudding.cool/ - art using web technology (1/wk)

https://www.experimental-history.com/ - psychology (1/wk)