[[reticulum_thejeshgn_com]]
  type = BackboneInterface
  enabled = yes
  remote = reticulum.thejeshgn.com
  target_port = 4242
  transport_identity = dc1414ac19f3c488bdd9c7badaf0862a

Setting it up and running as a system service wasn’t that difficult. There is enough information online to do. I did create a separate non-root user called rns just to run these services. Otherwise, it’s a standard Linux service.

Now that I have a machine. I thought I should make the most of it. So I also configured it to run the LXMF Propagation Node (store-and-forward for messages). Now I can use my own Propagation node for messaging purposes. It’s open to the public to use as a propagation server.

As you can see, the BackboneInterface and Node seem to be getting used. I have restarted the machine a couple of times to update the OS. I have created a Reticulum Project Wiki page to track my work.

Update: Now there is one more that is running in Mumbai, which is a good thing. I will try to find a cheap host in Bengaluru or Chennai.

LXMF (Lightweight Extensible Message Format) is a universal messaging protocol built on top of Reticulum. It’s a distributed (doesn’t need an account with a service provider), secure, versatile messaging system. It also supports store and forward (Propagation Node), so you can receive messages even when you are offline. It can also handle non-text messages, meaning you can send and receive MessagePacked data fields. For example, you can send telemetry, sensor data, etc.

There are quite a few apps. The quality of apps differs. They are all still evolving. Give them six months to a year; you’ll definitely see some good apps. At present, Desktop apps are generally better than mobile ones.

Some apps to try

• Sideband – Built by Mark Qvist, available on all platforms, including Android (Sideload). It feels more like reference implementation but it works. I use it for all my testing.
• Meshchat – A well-designed web browser app. It has lots of features. It works vey well.
• Nomadnet – It does more than messaging. It’s a CLI.
• Ratspeak – It’s designed well. Available for all platforms including Andoid (Sideload). I found some rough edges but otherwise good.

Don’t run the same Reticulum identity on two machines. The LXMF identity is tied to the Reticulum’s identity. So messages will land in one of them, and they may not arrive in order. It might confuse you. Also, since the identity is attached to Reticulum’s, you can either attach the messaging apps to an already running rnsd or let them run their own rnsd instance, depending on your needs. I usually suggest running the messaging application’s own rnsd and identity. That way, there is less setup to do.

Text is okay; what about calls? It’s possible, though it depends on your Interfaces that carry the packets. But Reticulkum community has LXST, for both voice calls and PTT. It supports OPUS and Codec2 codecs for voice. I have been able to make calls. But I prefer leaving voice messages. I choose Opus Low/Medium quality.

If you like to leave a message or chat. Contact me at my LXMF address : 0b1c6b8c0cfa77f7892715e130f49e66

Reticulum is the cryptography-based networking stack for building local and wide-area networks with readily available hardware. Reticulum can keep operating even in adverse conditions with very high latency and extremely low bandwidth.

Unlike Meshtastic or MeshCore, Reticulam is not a messaging platform (though you can add messaging on top of it). It’s a full replacement networking stack. You can have many applications on top of it once it’s running. Ordinary TCP/IP applications do not automatically run on it.

In Reticulum, every machine or node is identified by a pair of signing and encryption keys (transferable). I fact a machine can have more than one. This is used for both encryption and routing. Both key pairs use 32-byte keys. Together, the two public keys form a 64-byte public identity. But to identify the node, Reticulum uses an identity hash, which is derived from these public keys.

hash = SHA256(encryption public key + signing public key )
identity_hash = first_16_bytes(hash)

That is 128 bits, or 16 bytes, or 32 hex characters. This is what you usually see everwhere to identify the node.

To route the traffic, Reticulum uses a destination hash, which is an address of an application endpoint in Reticulum. So different applications within the same node get different destination hashes. A normal identity-backed destination is derived from:

• Application name, such as lxmf.
• Aspects that identify the service, such as delivery.
• Identity hash, identifying the key holder.

lxmf is a messaging protocol built on top of Reticulum.

name_hash = SHA256(b"lxmf.delivery")[:10] # First 10 bytes
destination_hash = SHA256(name_hash + identity_hash)[:16]

For rncp (file transfer utility like scp), the destination name is rncp.receive:

• Application: rncp
• Aspect: receive

The calculation is similar:

name_hash = SHA256(b"rncp.receive")[:10]
destination_hash = SHA256(name_hash + identity_hash)[:16]

This is how different applications on the same node can have different destination addresses. Packets are delivered to these destination addresses.

Applications can send an announce for their destination. An announce includes the destination’s public identity information and a signature that others can verify. As it travels through the network, nodes learn which direction that destination can be reached from and how many hops away it is. If a node does not know a path, it can request one.

Reticulum uses Transport nodes to carry traffic between other nodes, sometimes across different interfaces. Not every node needs to be a Transport node. Ideally a stationary, always on and available nodes can be a Transport node. A network needs relatively small number of Transport nodes.

Reticulam doesn’t have IP addresses, DNS names, etc. Everything is handled by cryptographic keys or hashes. Traffic is also encrypted end-to-end. All encryption keys are ephemeral, and communication offers forward secrecy by default. All of this is handled at the network level, and you don’t have to do anything as an application developer. The Reticulam protocol doesn’t support store-and-forward; the packets will be dropped if the destination couldn’t be reached or is down.

The network can use available mediums (like links, called Interfaces) to ship the packets. Your network can be heterogeneous based on your design. It can use SerialInterface (RS-232/485 line, serial radio modem, or XBee-style transceiver), PipeInterface (pipes packets through stdin/stdout), Internet (TCP), Local LAN, Ethernet or WiFi, automatically using IPv6 multicast. Bluetooth or other radio (LoRa, VHF/UHF/HF using KISS, AX.25 ), etc. Basically, it can use any medium as long as they transmit packets. You can configure more than one interface.

To get started, we will install rnsd (Reticulam Network Service Daemon). I installed it using UV, you can do pip if you want. It will install the rnsd and other utilities. Once installed, run rnsd to create a key pair. It usually creates a key pair in your home directory at ~/.reticulum. All your network keys are stored here. You can also edit ~/.reticulum/config to add interfaces. It comes with AutoInterface for local LAN/Wifi connectivity. But you can add one or two TCPClientInterface so you can send packets across the internet. You can start with an Interface provided by the community. It’s the easiest Interface to set up. If you change the config at any time, you need to restart RNS.

# using pip
pip install rns

# using uv
uv tool install rns

# run rnsd to create keys
rnsd

After that, you can create a system service if you’d like to run it as a service. I want it to run all the time, so I set it up that way. If not, you can start it manually whenever you want. You can check the status and traffic flow using `rnstatus`. It should show the status of all Interfaces and the traffic flowing through each one. Now you are on the network and ready.

To test you can pickup a node on Rmap, like this and see the path to it by running the command.

rnpath 5ee1bfcf91d35528c9dc22c083ea0594 # destination hash

It will print.

Path found, destination <5ee1bfcf91d35528c9dc22c083ea0594> is 7 hops away via 
<d7db22f63b453c23bb0688dde565b7c1> on BackboneInterface[PSHP G01/dyn1.intatec.com:4242]

Now you know you are on the network and can reach others on the Reticulam Network.

Next, install a useful app that can do something on this network, perhaps short messaging?

Requirements

• Known and proven brands that have supported the hardware for at least a decade. And not known for dropping products. No Google, Apple, or Samsung.
• It’s meant for outdoor use, so at least semi-rugged. Buttons and not just touch screen. Good readable screen.
• Good battery life
• It should work without a phone for at least a few days. I.e., good offline functionality. It should work without a network for sure.
• GPS and Offline Maps. Ability to run GPS/Maps for at least 24 hours.
• Good community, openness
• Cost. I had a fairly high budget of 50K.

Solution

I looked into Garmin, Coros, and Casio.

I chose the Garmin Forerunner 965. Other watches I considered were the Garmin Instinct 3, the Garmin Fenix® 7X Pro, and the Coros Nomad. I considered the Casio ProTek (WSD-F20) series, but neither the community nor the OS seemed interesting enough. But I do love how rugged they are. I will keep an eye on them.

Garmin Instinct 3 has everything except offline maps. It has a cool screen and GPS. But it has no routeable maps. It’s also expensive. Garmin Fenix® 7X Pro is better in every way, but it’s double the cost and weight. Coros Nomad is the closest competitor; it has all the features I wanted, at a similar price, and it’s rugged and pretty. But I don’t know anything about Coros; no one I know has it. Also, I don’t know much about the community around it. It’s also the brand that is on my list.

I was able to load Indian OSM maps onto my Forerunner 965. I have used it while running and for casual walking. I haven’t done much routing on the watch, though it’s possible. I could follow a GPX track easily. I will blog more. Overall, these features seem to work.

Everything on the phone works offline and also works without the phone. Of course, you can send messages without the phone (it doesn’t have a network), but it can connect to Wi-Fi if needed. It can also store music and play it through my Bluetooth earbuds. So you can go out without the phone.

I have not charged the watch much. I am quite active every day, so it’s not bad. I haven’t taken it out for a full day of motorcycling or trekking with maps/routing on. When I do that, I will write more.

The community around it is good, though they are more focused on outdoor activities and mapping. I haven’t explored their apps yet.

As I said, this is not a review. This is just the list of things that I looked for while buying this watch, held up against them. For how it performs in those areas, you will have to wait. And it won’t be a single blog post. For now, there are no red flags with the Forerunner 965.

Download

1. Go to BBBikes Garmin Page
2. Choose the format Garmin OSM (UTF-8). All modern Garmin devices can use UTF-8.
3. Select the area you want (bbox)
4. Click on Extract
5. Once it’s ready, you will get an email.
6. You can also check the progress on the status page and download it from there.
7. Extract the zip file to get .img file

Load

1. Plug into Ubuntu with USB; it should appear as mass storage.
2. It’s in the Garmin Connect App; On the top right, click on the watch. Go to System > USB Mode; set it to Media Transfer (MTP). Reattach and check.
3. In my case (Forerunner 965), I had to block the `garmin_gps` kernel module from loading. You can try that too.
4. Once that is done. Once you connect, the watch will ask for your permission to connect as mass storage
5. Say yes
6. It should appear as mass storage
7. Go to /Garmin/
8. Paste the downloaded .img file
9. Safely unmount the Garmin
10. Now go to the watch and go to Maps Manager
11. Your map file should be there
12. Open it and see

Quantization

Weights are represented by numbers in a model. A normal model might store each weight using 16 bits, i.e FP16 (half-precision floating-point). Quantization reduces that dramatically, where weights are represented using INT8 (8-bit integer) or INT4 (4-bit integer). They reduce precision but increase inference speed and reduce hardware requirements. Most of the time, quantization is performed post-training, which reduces model accuracy. But there is INT4 QAT (4-bit Integer Quantization-Aware Training), which does this during training, thereby reducing the extreme accuracy drops common with standard 4-bit quantization.

1 bit weight

1-bit goes one step further and asks: what if the weights were just one bit, and if that were done during training? With exactly 1 bit per weight, each weight can have only 2 possible values. 0 or 1. 0 represents -1 and 1 represents +1. i.e., instead of storing numbers like 0.72, -0.13, 1.24, -0.56, we will store +1, -1, +1, -1. That is at least 16 times less storage for weights theoretically.

1.58 bit weight

In 1.58-bit weights (ternary bit weights), there are three possible values: {-1, 0, +1}. Theoretically, we need log2(3) bits of information to distinguish between 3 possible states : 2^x=3. i.e. log₂​(3)≈1.585. Hence the name.

For our interpretation and understanding:

• 0: the input is effectively ignored for that connection. i.e., no influence at all, which also gives you built-in sparsity.
• +1: the input contributes positively to the output. i.e., an increase in the input pushes the weighted sum up. This is “same-direction” influence.
• -1: the input contributes negatively. i.e., an increase in the input pushes the weighted sum down. This is “opposite-direction” influence.

1.125-bit weight

1.125-bit applies different logic for compression and calculation. One can’t literally allocate 1.125 bits per weight. The way this works is that the average bit allocation is used when they are packed. For example, it takes 9 bits to store 8 weights; thus, the average number of bits per weight is 1.125. One important distinction here is that bits per weight doesn’t necessarily tell you how many values each individual weight can take. 1.58 has a clean theoretical connection to three states, while 1.125 bpw usually describes the overall encoding/storage scheme. The table below should make a bit clear

BitNet b1.58 2B4T

This is the first open-source, native 1-bit Large Language Model (LLM) at the 2-billion parameter scale, developed by Microsoft Research. You can find the model on the hugging face, it needs a specific inference code called bitnet.cpp.

Bonsai models

Bonsai 1-bit models are probably the first set of production-ready binary/ternary models. They have 1.7B, 4B, 8B, and 27B parameter models.

I have been running the 8B-parameter version locally. My experience with it has been positive. I have explored it for text summaries, code explanations, etc. I will try to install the 27B version and do some coding to see how it goes.

# Install llama
curl -LsSf https://llama.app/install.sh | sh
# Serve the model using OpenAI-compatible API and a web ui
llama serve -hf prism-ml/Bonsai-1.7B-gguf:Q1_0
# or 8B parameter version
llama serve -hf prism-ml/Bonsai-8B-gguf:Q1_0

Note: Yes, I have moved away from Ollama and now mostly use llama.cpp. Also I sometimes Jan.ai along with OpenWebUI

After that, I wanted an easy way to embed it on any web page. I chose to use web components. It converts the given list of exercises into muscle groups, then applies styles to them within the SVG and embeds the SVG. I have verified it to the best of my knowledge and from available sources. It took a lot of battling with Claude to make it the way I want, that is, to make it generic and reusable. I still have to map a bunch of muscle groups, I have listed all the short comings in the readme.

Finally, I created a WordPress shortcode to queue the JavaScript and embed the component. But that’s not really required. If you have a simple static site, then you can include SVG and a JS file and use the muscle-map tag in your HTML

Wednesday Workout

Run

Calf raise, Tibialis raise

Calf raise

Happy workout and happy logging.

In response to these aggressive moves by the platforms, I have started adding the data directly to the visible part of the image, like how your old film camera would add the date/time directly onto the photo itself. There is no danger of losing that information. As long as I have the picture, I have the date/time it was taken.

Similarly, now, when I take certain pictures, I add text directly to the bottom-right corner, usually in English. I am making sure it has good contrast so humans and OCRs can pick it up easily. I have scripts to extract this data easily if I want to process it. Of course, any cheap visual model can also do it, but it’s easy and cheap to make the model write code and reuse it.

I have also started playing around with adding text to a QR code and then placing it on top of a Photo/Image. It works very well. It makes it much easier for machines to read and can also be read by humans using almost any phone camera.

The Apps that I use are

1. OpenCamera (F-Droid, Play): The most flexible camera app I have used. It’s open source. I use the GPS and Text stamping features a lot. It adds GPS tags, a timestamp, and a line of text on top of the image. I wish it had some more text features, but it works. All my new OpenPostboxIndia project pictures are taken with this. So unlike my first set of pictures, however they are maintained or transmitted, that data will remain with them. It can also be configured to take a sequence of pictures (like a timelapse) that can be uploaded to Panoramax. I also love that it can record video along with the GPS tags as a separate subtitle text.
2. ImageToolBox (FDroid, Obtanium and Play): A FOSS Swiss Army knife of image editing and annotating images or pictures on Phone. It has a ton of tools; some aren’t even directly related to image manipulation, like PDF Tools. So take your time to check out all the tools. Recently I discovered OCR tools and some local AI-based tools. All useful. I generally use the built-in QR code generator, then the watermarking feature to add that QR code to the image. Sometimes I use it for hand drawn notes or markers on top of pictures. I am still exploring this app. I am sure I will fit it into my other workflows and uninstall some other apps.
3. BinaryEye (FDroid, Play) is a dedicated QR Code (Barcode) scanner and creator App. It works well and can also do other things, like forwarding the scanned content to a a web endpoint or working as a remote Bluetooth scanner.

Do you annotate photographs or pictures? If yes, why? and What tools do you use?