neon

Perhaps you mean to say that you're waiting for a new scripting language to be created that's designed to be "almost Rust." That could be interesting! OTOH, the bindings for existing languages have matured significantly: - https://pyo3.rs/ - https://github.com/neon-bindings/neon - https://github.com/mre/rust-language-bindings

Great interview! Love how much thought is being put into what you “gold-plate”. I’ve always felt that my best work comes around on round two (or three or four…). Curious what you are planning for the ability to script the configuration? I haven’t played with zed much yet; is it possible today? Would something like Neon [1] help bridge the gap from VSCode and old Atom users? [1]: https://github.com/neon-bindings/neon

I worked on a very interesting project aligning point clouds using SVD, for a pair of point clouds of the same scene that are not aligned: - select 3+ pairs of matching points in each cloud (tops of trees, edges of a building etc) - calculate the vector to the centroid of each cloud - use SVD to calculate the rotation that gives a minimum distance when applied from the source to the target - translate and rotate the source cloud to the target I did this using the rust nalgebra^1 crate after reading a very helpful paper^2 detailing the process. I had planned to build the rust lib into WASM so the process could be run alongside the browser based point cloud visualiser we were using, but had limited time and instead used Neon^3 to build a native binding for our nodejs server to use. ^1 https://docs.rs/nalgebra/latest/nalgebra/linalg/struct.S

> rust is not well-suited for interfacing with FFI How so? Packages like neon [1] and rustler [2] suggest otherwise. I'm using both of those in a real product (I'm using neon directly, to write native modules for an Electron app; on the back-end, I depend on an Elixir package that uses rustler). [1]: https://github.com/neon-bindings/neon [2]: https://github.com/rusterlium/rustler

You can always extend Electron apps with platform-native capabilities. Things like Neon [1], a wrapper for writing node bindings in Rust, make this particularly convenient. You can then use Rust to call into platform native APIs. It's more work, but you can still benefit from cross platform UI development and augment it with native code where appropriate. [1] https://github.com/neon-bindings/neon

If you want to interface with Node from Rust there's a great library called Neon[0] that wraps the C/C++ Node addon api. [0] https://github.com/neon-bindings/neon

This reminds me of this writeup on doing something similar, with Rust as the native core for an electron app; the Rust in this case is in-process, written using "neon". This app (Finda) hit a performance target of 16ms rerenders for incremental browser history + desktop file search - computers are fast, even if you use Electron. - https://keminglabs.com/blog/building-a-fast-electron-app-wit... - https://github.com/neon-bindings/neon (edited for formatting)

If you want to see some examples, Neon uses this pattern to solve a similar problem - preventing rust code from holding onto js objects that might get gced between callbacks. https://github.com/neon-bindings/neon

We are using it to write Express (node.js) middleware via Neon (https://github.com/neon-bindings/neon). This has a few key benefits: * Progressively introduce Rust instead of replacing entire applications (Rust really shines in this area) * Leverage node's strong HTTP and routing story while waiting for this to stabilize in Rust * Leverage existing tooling for APM, config management, etc. For example, one middleware verifies the request body with a signature from a header. Another one parses the body from a `Buffer` to JSON, transforms, and serializes as protobuf.

Fortunately, you don't have to use C for this any more. Rust has bindings for making extensions for Ruby, Python, Lua and Node, and generally it's very well suited for making zero-cost cleaner APIs on top of C FFI. https://github.com/tildeio/helix https://github.com/PyO3/pyo3 https://github.com/kyren/rlua https://github.com/neon-bindings/neon

Node is actually a bit lack luster to write extensions for in C, as it prefers to go through v8's C++ abi. Same for LLVM: they have a half baked C interface to what's really a C++ abi. There's an alright attempt at allowing for Rust bindings in node: https://github.com/neon-bindings/neon Because C is so raw bone, highly generic APIs from higher level languages can come off as rather lackluster when reduced to C's world view

Incorrect. Rust does very well at embedding into those dynamic languages. It exports the same ABI C. In fact, due to how well its compilation tools work, IMO it's actually easier to use Rust than C to embed into those languages. The "infrastructure" is usually a just a C header. For Node.js it's more C++, but you'd need to write C++-to-C glue anyways just like you'd need C++-to-Rust glue (of course there's neon [0] that makes this easy). Basically, for most FFI-based use cases, anything that C can do Rust can do. 0 - https://github.com/neon-bindings/neon

Thanks to Rust's great C interoperability, hybrid can be a great approach. I've really been enjoying re-writing sections of node.js applications in Rust. It fits fairly seamlessly and can really broaden the scope of what is possible. https://github.com/neon-bindings/neon