misterdata

Synctrain is an open source (MPL2.0) iOS Syncthing client (which I made) with full native mobile-first UI and tight iOS integration (shortcuts, background processing, etc).

You are most likely in France: your government does not allow publishing an app containing cryptography (in this case, Golang's crypto implementations and a package used by Syncthing - only using iOS libs should be fine) without authorization (which can only be obtained through French forms, at which point I'd want a French lawyer to be involved, so no).

You could of course build the app yourself from source.

If you’re on iOS, try my (FOSS) app for Syncthing: https://github.com/pixelspark/sushitrain

Also “apenstaartje” in Dutch (monkey’s tail)

See also this 3D model of Shinjuku station, Tokyo:

https://satoshi7190.github.io/Shinjuku-indoor-threejs-demo/

For iOS: https://github.com/pixelspark/sushitrain

Similarly, Trixie contains an updated version of Dovecot that (even though the version number seems to indicate otherwise) has a new configuration format that is not backwards compatible. This is clearly stated in the release notes but may be surprising nevertheless.

So, basically any local productivity tool, saving files in a synced folder.

While this works, Syncthing does not really provide anything for fine-grained collaboration or sharing (you only share full folders). Encrypted peers do allow storing files on a machine that you don’t have to trust.

This is cool!

Any tips for an app to use on iOS to capture the necessary .ply data?

Scaniverse is a great app by Niantic that can do this on-device, but it isn't very customizable and can't export its raw scanning data (exported .plys do not have the data this editor requires).

In my neighborhood (Netherlands) it appears the fiber network is physically point-to-point (subscriber to ODF), but is operated as XGS-GPON (so all subscribers see the same light signal so to say, but each over their own ptp fiber from the ODF). So point-multipoint only at the active layer.

I was told that this is because the company who is rolling out the fiber wants to make the network as attractive as possible to ISP’s who want to offer services over it (and wants them to compete) which may be more difficult in an actual physical point-multipoint network (which requires PON). The ISP currently likes PON more than AON (basically Ethernet over fiber to a switch) because the equipment is cheaper. In theory I should be able to switch to an ISP who offers AON or its own PON (they’d only have to physically patch my fiber in a different port at the ODF).

Author here, I guess I could have chosen a better title. This article is about diving into complexity that seems insurmountable at first, with an engineer's mindset.

Author here - this figure is insane but also a bit of an exaggeration. I calculated it by running 'cloc' on the source code directory, not excluding node_modules. Many modules in there are actually unused or only used at build time. The built output (from Nuxt) that is actually run is much more compact (though partly minified so line counts are not that interesting). Also, Nuxt specifically is a bit overkill here, but greatly improved my productivity developing this website (and was chosen because it aligns with our other web applications, so less 'innovation tokens' [1]).

[1] https://boringtechnology.club

Not a single mention of the word ‘Apple’ in the original post, instead ‘the manufacturer’ and ‘the big corporation’.. curious if that is deliberate and if so what the reasoning is (legal?)

As they are accepting a JSON schema for the function calls, it is likely they are using token biasing based on the schema (using some kind of state machine that follows along with the tokens and only allows the next token to be a valid one given the grammar/schema). I have successfully implemented this for JSON Schema (limited subset) on llama.cpp. See also e.g. this implementation: https://github.com/1rgs/jsonformer

Also WONNX can both be used from native apps (through wgpu it uses Vulkan, DX or Metal) a well as on the web (using WebGPU, WONNX compiled to WebAssembly).

Also see the recently introduced StableHLO and its serialization format: https://github.com/openxla/stablehlo/blob/main/docs/bytecode...

Actually WONNX also transforms to an IR first (early versions did not and simply translated the graph 1:1 to GPU shader invocations in topographically sorted order of the graph). In WONNX the IR nodes are (initially) simply (copy-on-write references to) the ONNX nodes. This IR is then optimized in various ways, including the fusion of ONNX ops (e.g. Conv+ReLU->ConvReLU). The newly inserted node still embeds an ONNX node structure to describe it but uses an internal operator.

Looking forward to your WebGPU ML runtime! Also, why not contribute back to WONNX? (https://github.com/webonnx/wonnx)

This makes running larger machine learning models in the browser feasible - see e.g. https://github.com/webonnx/wonnx (I believe Microsoft's ONNXRuntime.js will also soon gain a WebGPU back-end).

You can indeed perform inference using WebGPU (see e.g. [1] for GPU-accelerated inference of ONNX models on WebGPU; I am one of the authors).

The point made above is that WebGPU can only be used for GPU's and not really for other types of 'neural accelerators' (like e.g. the ANE on Apple devices).

[1] https://github.com/webonnx/wonnx

Replacement for the ONNX IR perhaps, but as far as I can see there is not (yet?) a file format for StableHLO (ONNX has a standardized on-disk format specified in Protobuf)

Also, Vega [0] and Vega Lite [1]

[0] https://vega.github.io/vega/ [1] https://vega.github.io/vega-lite/

Not sure about WiFi but the idea exists in the 5G standard as ‘coordinated multipoint’ (CoMP)

Some APs (eg Ubiquiti) can actually steer clients from one band to the other based on minimum RSSI and other parameters (including device compatibility, and you can exclude or force a band for individual devices), which prevents this from happening.

I built a "PowerPoint/Excel hybrid" that can make forms like this and some more: https://dialogiconderzoek.nl/diadashboard/platform/diaslide_...

If I understand correctly that’s 'Streaming ACN' e.g. more or less DMX512 over IP. In that case the image is generated on a beefy lighting desk/computer, not on the microcontroller inside the fixture (which is what this and e.g. the Lua project linked in another comment does)

WLED (firmware for ESP8266) appears to support E1.31 [1] as well as Art-Net and the WLED custom protocol referenced in the article.

[1] https://github.com/Aircoookie/WLED/wiki/E1.31-DMX

This looks cool! Lua obviously is a much more mature language. I'd expect it to use a fairly complex interpreter (LuaJIT is not available for esp8266 I assume..) so this is likely a bit less efficient (even though the Lua interpreter is probably well-optimized, it is simply more complex) but obviously much more functional than my toy language.

Floating point is just not very fast on ESP8266 (I believe it could even be softfloat, so emulated in software?).

Nevertheless it shouldn't be that difficult to change the interpreter to use floats instead of ints as base type (mixing the two would be more involved I think).

The interpreter will throttle the program to a certain frame rate - it will suspend the program on each ‘yield’ instruction and resume the program when a new frame is needed. It can also ignore the yields to get as high a frame rate as possible. Programs should not poll but use get_precise_time to draw what is necessary for that time stamp.

(And yes, the LEDs use way more power than the CPU here)

This was actually built between 2012-2013 - it is quite a tangle of old and rusty (but very reliable) PHP code and IE9-era, 'jQuery-esque' JavaScript. Realistically this can't be usefully made open source (and if it were it would probably have to be rewritten in order to be more generally useful). That said I would be very interested in an open source re-implementation of this using modern techniques!