The simplest way is to download the latest binary release that corresponds to your architecture.

Note that it contains dependencies, — .so files in deps/, — which provide portability: aelhometta_using_deps.sh should work whether these libraries are present system-wide or not. See also *-unknown-linux-gnu-related part of build.rs.

To install dependencies from the official repository system-wide (on Debian-based distros):

$ sudo apt install libzmq3-dev

Or build Ælhometta from source: install the same dependencies as above, then install Rust toolchain, download the source e.g. to ~/rust/aelhometta/, and from there

$ cargo build --release

Next stop down the rabbit hole is to build from source the libzmq dependency of Ælhometta and its core dependency that provides security, libsodium. This has its own "costs" (of toolchain setup and compilation issues... most of the rest of this section belongs to C/C++ world, Rust is mentioned briefly in the end), but allows better device-specific tuning (e.g. --enable-opt option of libsodium's configure) and lessens the number of shared libraries you have to pack with the executable; usually these 2 suffice, in comparison with additional libpgm, libnorm, libcomm_err, ... from official repositories with "all-included" libzmq. Evidently, this step is mandatory when there are no prebuilt binaries/libraries for the device at hand.

Hereinafter we assume that libsodium and libzmq are not installed system-wide, so that they do not interfere with building process as wrong dependencies.

• install build tools:

$ sudo apt install cmake

(it will install make too as recommended)

I) libsodium

• download libsodium-X.Y.Z[-stable].tar.gz from https://download.libsodium.org/libsodium/releases/, extract its main content to e.g. ~/libsodium/, and create build dir there. You may have to add the content of src/ dir to ~/libsodium/src/.

$ sudo apt install g++

$ ../configure
$ make -j 8

$ sudo apt install g++-aarch64-linux-gnu

#!/bin/sh

export CFLAGS='-Os'
../configure --host=aarch64-linux-gnu
make -j 8

II) libzmq

• download zeromq-A.B.C.tar.gz from https://github.com/zeromq/libzmq/releases to e.g. ~/zeromq/, create build dir inside

• create sysroot dir in ~/zeromq/build/ and within it

  • place a copy of ~/libsodium/src/libsodium/include/ dir (or symlink to it), with version.h file from ~/libsodium/build/src/libsodium/include/sodium/

  • create lib dir, copy into it libsodium.so, libsodium.so.A etc. — you've built those in (I) — from ~/libsodium/build/src/libsodium/.libs/ (or make it the symlink to .../.libs/)

• prepare genvars.cmake file in ~/zeromq/build/ with the following content:

set(BUILD_STATIC OFF CACHE BOOL "")
set(BUILD_TESTS OFF CACHE BOOL "")
set(WITH_LIBBSD OFF CACHE BOOL "")
set(WITH_LIBSODIUM ON CACHE BOOL "")
set(ENABLE_CURVE ON CACHE BOOL "")

• prepare toolchain file for CMake, toolchain.cmake, in ~/zeromq/build/ (based on this, that, another one, and CMake documentation)

  • 1st part of toolchain.cmake:

set(CMAKE_FIND_ROOT_PATH ${CMAKE_BINARY_DIR}/sysroot)

set(TOOLCHAIN_PREFIX aarch64-linux-gnu)

set(CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}-gcc)
set(CMAKE_CXX_COMPILER ${TOOLCHAIN_PREFIX}-g++)

set(CMAKE_FIND_ROOT_PATH /usr/${TOOLCHAIN_PREFIX};${CMAKE_BINARY_DIR}/sysroot)

• • 2nd part of toolchain.cmake:

set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)

set(CMAKE_CXX_FLAGS "-static-libgcc -static-libstdc++")

set(ENV{PKG_CONFIG_LIBDIR} ${CMAKE_BINARY_DIR}/sysroot/lib/pkgconfig)

set(CMAKE_SKIP_BUILD_RPATH true)

Checkpoint: the structure of the build tree should be

~/zeromq/build/
|--sysroot/
|  |--include/
|  |--lib/
|--genvars.cmake
|--toolchain.cmake

• Change dir to ~/zeromq/build/ and run

$ cmake -DCMAKE_TOOLCHAIN_FILE=toolchain.cmake -C genvars.cmake ..
$ cmake --build . --config Release -j 8

Remark on cleaning. Reset build dir to its initial state with a script such as (note bash instead of sh)

#!/bin/bash

shopt -s extglob
rm -rf !("sysroot"|"genvars.cmake"|"toolchain.cmake")

Remark on x86_64-to-i686 cross builds. The toolchain is g++[-9]-multilib; if g++-multilib conflicts with something pertaining to ARM cross-tools, remove it, but keep its "numbered" version, e.g. g++-9-multilib. To CFLAGS and CMAKE_CXX_FLAGS variables add -m32. Also, you may need to add /usr/include/asm symlink to /usr/include/asm-generic/.

Remark on building libsodium via Zig. One more option, install Zig and follow these instructions.

Assuming (I) and (II) were successful, you then place obtained shared libraries, .so files/symlinks of libsodium and libzmq, where Rust toolchain will be able to "pick up" them — into ~/rust/aelhometta/target/TARGET/release/deps/ (here TARGET is, well, target such as aarch64-unknown-linux-gnu). libsodium.so.M and libzmq.so symlinks suffice.

And finally, from ~/rust/aelhometta

$ cargo build --release [--target i686-unknown-linux-gnu]

or, if Cargo cannot choose proper linker on its own,

$ RUSTFLAGS="-C linker=aarch64-linux-gnu-g++" cargo build --release --target aarch64-unknown-linux-gnu

Since the Ælhometta executable that comes out of this is "tuned" to the built versions of the libraries, they must be shipped with it. As an example, see Linux-targeted binary releases: there is deps dir with libsodium.so.M and libzmq.so.N, and the script that runs the executable tells dynamic linker/loader to look for them in that dir. In the simplest case when you run the executable from the same dir in which it resides,

$ LD_LIBRARY_PATH=deps:$LD_LIBRARY_PATH ./aelhometta

is enough.

Remark on symlinks. Use them, if you go through many iterations of building process, to avoid copying, again and again, of an updated library to the build tree of a dependent program. For instance, make ~/zeromq/build/sysroot/lib/ the symlink to ~/libsodium/build/src/libsodium/.libs/.

is a case unsurprisingly similar to the Linux one, except for brew instead of apt, zeromq instead of libzmq, and few other distinctions.

Begin with the latest binary release for your architecture.

.dylib files in deps/ provide portability: aelhometta_using_deps.sh works whether these libraries are present system-wide or not.

To install dependencies system-wide, install the Homebrew package manager first, following the instructions at https://brew.sh/. Inter alia, Xcode Command Line Tools will be installed. Then

$ brew install zeromq

Or build Ælhometta from source: install the same dependencies as above, then install Rust toolchain, download the source e.g. to ~/rust/aelhometta/, and from there

$ cargo build --release

(1st time it may fail due to absence of cc, but macOS should then offer to install the toolchain in popup window.)

You can also build from source the libzmq dependency of Ælhometta and its core dependency that provides security, libsodium. For example, when $ brew install zeromq fails (should we say breaks? spills?), or when you need better device-specific tuning (e.g. --enable-opt option of libsodium's configure).

In fact, on old versions of macOS, this way is much faster than $ brew install zeromq — we're talking minutes vs. hours here — because the latter installs 20 or so dependencies, most of which are built from source as well.

Here we consider mostly native build process, from macOS on MacBook to macOS on MacBook, save perhaps different arch (see remark at the end). Of course, there are cross alternatives, QuickEmu being one of them (take into account this manual, adding ram="<something>G" to macos-<version>.conf along with decreasing 8 in if [ "${RAM_VM//G/}" -lt 8 ]; then line of /usr/bin/quickemu, and --extra_args "-cpu host" argument of quickemu call).

For the sake of simplicity we assume that libsodium and libzmq are not installed system-wide; if they are, they may interfere with building process as wrong dependencies.

• install build tools:

$ brew install cmake pkg-config

I) libsodium

• download libsodium-X.Y.Z[-stable].tar.gz from https://download.libsodium.org/libsodium/releases/, extract its main content to e.g. ~/libsodium/. You may have to add the content of src/ dir to ~/libsodium/src/

• from ~/libsodium/, run the usual:

$ configure
$ make -j 8

II) libzmq

• download zeromq-A.B.C.tar.gz from https://github.com/zeromq/libzmq/releases to e.g. ~/zeromq/, create build dir inside

• create sysroot dir in ~/zeromq/build/ and within it

  • place the include symlink to ~/libsodium/src/libsodium/include/ dir

  • place the lib symlink to ~/libsodium/src/libsodium/.libs/ dir

• prepare genvars.cmake file in ~/zeromq/build/ with the following content:

set(CMAKE_PREFIX_PATH ${CMAKE_BINARY_DIR}/sysroot CACHE PATH "")

set(BUILD_STATIC OFF CACHE BOOL "")
set(BUILD_TESTS OFF CACHE BOOL "")
set(WITH_LIBSODIUM ON CACHE BOOL "")
set(ENABLE_CURVE ON CACHE BOOL "")

Checkpoint: the structure of the build tree should be

~/zeromq/build/
|--sysroot/
|  |--include/
|  |--lib/
|--genvars.cmake

• Change dir to ~/zeromq/build/ and run

$ cmake -C genvars.cmake ..
$ cmake --build . --config Release -j 8

Assuming (I) and (II) were successful, you then place the symlink to the built shared library libzmq.dylib where Rust toolchain will be able to "pick up" it — into ~/rust/aelhometta/target/release/deps/.

And finally, from ~/rust/aelhometta/,

$ cargo build --release

The Ælhometta executable you obtain this way is "tuned" to the built versions of the libraries, libsodium.M.dylib and libzmq.N.dylib, so they must be present somewhere near, and you load it with DYLD_LIBRARY_PATH pointing to their location. As an example, see macOS binary release. In particular, when you run the executable from the same dir in which it resides, and .dylibs are in deps subdir:

$ DYLD_LIBRARY_PATH=deps:$DYLD_LIBRARY_PATH ./aelhometta

Remark on building from x86_64 to aarch64 or vice versa. Almost the same story, but the script for building libsodium better take form of a file, say, build.sh inside ~/libsodium/, with

#!/bin/sh
export CC="cc --target=aarch64-apple-darwin"
export CFLAGS="--target=aarch64-apple-darwin"
../configure --host=aarch64-apple-darwin
make -j 8

(without this duplication of --target=..., .dylib files are absent or "hollow"), and similarly libzmq is built by

$ cmake -DCMAKE_C_FLAGS="--target=aarch64-apple-darwin" -DCMAKE_CXX_FLAGS="--target=aarch64-apple-darwin" -C genvars.cmake ..
$ cmake --build . --config Release -j 8

Currently, Ælhometta on such systems runs as native executable in Termux, so install it first and right away update its packages via $ pkg update && pkg upgrade. Please remember that executables should be inside ~ of Termux (= /data/data/com.termux/files/home), not anywhere on internal memory or external SD; $ termux-setup-storage will provide access to the part of external SD under Android/data/com.termux/files, which you can use to bring Ælhometta's binary to, for example, ~/aelhometta/ via $ cp within Termux itself.

Rooting is not required for this.

Dependencies:

$ pkg install libzmq

You can get the latest binary release (which includes dependencies, .so files in deps/) for armv7 or aarch64 accordingly (hint: use $ lscpu in Termux).

Alternatively, build from source; the rest of this section describes how.

1. Native build. Use Rust package for Termux, not the script from https://sh.rustup.rs:

$ pkg install rust

The rest of the building process is the same as in Linux case, except for $ pkg install libzmq instead of $ sudo apt install libzmq3-dev.

2. Cross build. You need another x86_64 or i686 device with Linux. There,

• download the latest Android NDK for Linux and extract it to e.g. ~/android-ndk-r26d/. SDK/Studio would be redundant. Be careful to retain symlinks in .zip of NDK during extraction, or else it will not work — C compiler cannot create executables errors of configure appear; produced by clang invocation, they kind of mislead... no input files, posix_spawn failed: exec format error etc. This comment suggests using command line unzip instead of built-in extractors of file managers with GUI

• install Rust toolchain

• get Ælhometta's source

• get .deb file of libzmq package from https://packages.termux.dev/apt/termux-main/pool/main/ and browse it as archive in Midnight Commander (or $ ar x package.deb && tar -x -f data.tar.xz). You need libzmq.so from usr/lib/, copy it to .../aelhometta/target/TARGET/release/deps/

• finally, from source dir,

$ RUSTFLAGS="-C linker=$HOME/android-ndk-r26d/toolchains/llvm/prebuilt/linux-x86_64/bin/aarch64-linux-android21-clang++" cargo build --release --target aarch64-linux-android

(or similar for armv7[a]-linux-androideabi instead of aarch64-linux-android) to obtain the binary in target/TARGET/release

cross crate is an alternative to Android NDK, it requires some dependencies in turn, Docker Engine in particular. Then you do not specify RUSTFLAGS and replace cargo build ... with cross build ...

Note Termux-specific library path, hardcoded into the binary, in build.rs. There is also the option to link statically.

#!/bin/sh

# export MIN_SDK_VERSION=21

export NDK_VERSION=android-ndk-r26d
export ANDROID_NDK_ROOT=$HOME/${NDK_VERSION}

export CURVE=libsodium
export LIBSODIUM_ROOT=$HOME/libsodium

./build.sh arm64

The latest binary release contains the executable and the .dll dependencies.

Or build from source, in which case comes first the captivating task to produce linking and runtime ZeroMQ libraries from libzmq latest release by means of some C/C++ toolchain, CMake, and Sodium... if you do not obtain them, prebuilt, from somewhere else.

set(CMAKE_PREFIX_PATH ${CMAKE_BINARY_DIR}/sysroot CACHE PATH "")

set(BUILD_STATIC OFF CACHE BOOL "")
set(BUILD_TESTS OFF CACHE BOOL "")
set(WITH_LIBSODIUM ON CACHE BOOL "")
set(ENABLE_CURVE ON CACHE BOOL "")

> cmake -C genvars.cmake ..
> cmake --build . --config Release -j 8

$ sudo apt install cmake mingw-w64

set(CMAKE_SYSTEM_NAME Windows)
set(CMAKE_SYSTEM_VERSION 10.0) # 6.1 -> Windows 7, 6.2 -> Windows 8, 6.3 -> Windows 8.1, 10.0 -> Windows 10
set(TOOLCHAIN_PREFIX ARCH-w64-mingw32)

set(CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}-gcc)
set(CMAKE_CXX_COMPILER ${TOOLCHAIN_PREFIX}-g++)
set(CMAKE_RC_COMPILER ${TOOLCHAIN_PREFIX}-windres)

set(CMAKE_FIND_ROOT_PATH /usr/${TOOLCHAIN_PREFIX};${CMAKE_BINARY_DIR}/sysroot)

set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)

set(CMAKE_CXX_FLAGS "-static-libgcc -static-libstdc++")

set(ENV{PKG_CONFIG_LIBDIR} ${CMAKE_BINARY_DIR}/sysroot/lib/pkgconfig)

set(BUILD_STATIC OFF CACHE BOOL "")
set(BUILD_TESTS OFF CACHE BOOL "")
set(ZMQ_CV_IMPL none CACHE STRING "")
set(WITH_LIBBSD OFF CACHE BOOL "")
set(WITH_LIBSODIUM ON CACHE BOOL "")
set(ENABLE_CURVE ON CACHE BOOL "")

$ cmake -DCMAKE_TOOLCHAIN_FILE=toolchain.cmake -C genvars.cmake ..
$ cmake --build . --config Release -j 8

Now zmq.lib (native) / libzmq.dll.a (cross) — the linking library — should appear in build/lib/; and libzmq-....dll (native) / libzmq.dll (cross) — the runtime library — in build/bin/.

Then, — assuming that Rust toolchain is installed and Ælhometta's source is downloaded to .../aelhometta/, — copy linking library to .../aelhometta/target/TARGET/release/deps/ (where TARGET is either x86_64-pc-windows-msvc (native) / x86_64-pc-windows-gnu (cross) or i686-pc-windows-...).

If the compilation is a cross one, add required targets:

$ rustup target add x86_64-pc-windows-gnu i686-pc-windows-gnu

Produce the binary:

$ cargo build --release [--target ARCH-pc-windows-gnu]

from Ælhometta's source dir.

Lastly, before running the binary, you need to place the following .dll-s in the dir with it:

• libzmq.dll — from the output of libzmq building process described above

• libsodium-MN.dll — from Sodium release, which you also have got during a building process

Additionally, in case of cross build:

• libwinpthread-1.dll and libgcc_s_seh-1.dll (64-bit) / libgcc_s_[dw2|sjlj]-1.dll (32-bit) — from wherever, e.g. from /usr/x86_64-w64-mingw32/lib/ and /usr/lib/gcc/x86_64-w64-mingw32/9.3-posix or WinLibs toolchain for MinGW-w64

If there are no prebuilt binaries and emulation via e.g. QEMU is not an option, what remains is to build from source. Install Rust toolchain, download Ælhometta's source to .../aelhometta/, and from there

$ cargo build --release

should proceed almost to the end... when linking stage fails with -lzmq not found-like error. Well, now you need libzmq, both linking- and runtime-dependencies. Search at your OS repositories, Internet, try to build it, in turn, from source (see Linux case).

This is not impossible, because all cases above were here before. The more platforms are covered, the more hookable ones for whom they are native will be hooked and make the first tiny step that follows:

where ælhometta is contained in the memory of your computer, does not reach other computers and does not interact with outside world.

Type in the following commands:

Æ anc b 5
Æ r

(which is the same as

Æ ancestor b 5
Æ run

but with aliases). That is, we introduce an ancestor — of type B, with spacity 5 — and let the environment tick on its own. At each tick, a controller is chosen randomly from the set of all controllers, processes the content of the node it currently "looks" at, and moves to the next node.

The charts on the right visualise relative frequencies of executed commands and other instructions. In the beginning, NextOptuid should be the most frequent one.

Wait for half a minute or so, then press (almost) any key to stop ticking. There should be many more nodes and controllers, like this:

[0:00:29] Age 1934061 : Nodes 3645220 | Controllers 14159
[0:00:30] Age 1965719 : Nodes 3702543 | Controllers 14346

Lastick 2024.01.16 Tue 12:00:30.292 UTC - Age 1974509 : Nodes 3720924 | Controllers 14407 | Limit 4194304=2^22 : Memory ~ 192 MiB
Æ █

Observe more statistics:

Æ stat cgen
Æ stat ctick
Æ stat chan
Æ stat cont
Æ stat run

By now, content statistics (Æ stat cont) mostly contains 0s, because only a fraction of all available commands and instructions are present in ancestor B and its exact replicas-descendants. Let's introduce random mutations, or glitches:

Æ glitch back 0.001
Æ glitch repl 0.03
Æ glitch cons 2.5e-2

Then again

Æ r

After a while, stop and compare new content statistics to the old one.

To see how the structure of chains has changed in details, pick up random controller's uid — CTRL-UID (8 hexadecimal digits) — by

Æ rand ctrl

and see that controller's state:

Æ sct CTRL-UID

The start node of the chain to which that controller is attached is given under ChainStart, we denote it by NODE-UID. Follow the chain from the start:

Æ ss NODE-UID

Disappointment: the sequence will be almost the same as that of the original entity, described in Ancestors. Has evolution stuck?

where ælhometta interacts with other computers (or rather ælhomettas on them), but not (directly) with outside world.

Assuming 2 ælhomettas running on 2 devices are at Abiohazard Level 1 already, you need additionally

• from your side:

  • 40-character Curve public and secret keys in Z85 format
  • 56-character onion address and port (0–65535) of Tor hidden service running on your device

• from other device's, or its owner's, side:

  • 40-character Curve public and secret keys in Z85 format
  • 56-character onion address and port (0–65535) of Tor hidden service running on that device

Here's how to do it quickly:

$ pip3 install -U pyzmq

import zmq
public, secret = zmq.curve_keypair()
print("Public key:", public.decode("ascii"))
print("Secret key:", secret.decode("ascii"))

$ pkg install libzmq
$ curve_keygen

If on Linux, set up Your Onion Service, skipping Step 1, because you do not need a web server. Verify that Tor service runs via $ systemctl status tor@default and obtain onion address from hostname file in the dir specified with HiddenServiceDir.

$ brew install tor

HiddenServiceDir /usr/local/var/lib/tor/hidd_aelhom_srv1/
HiddenServicePort 60847

$ brew services start tor

$ pkg install tor
$ pkg install termux-services

HiddenServiceDir /data/data/com.termux/files/usr/var/lib/tor/hidd_aelhom_srv1/
HiddenServicePort 60847

$ sv-enable tor
$ sv up tor

> tor --service install

HiddenServiceDir C:/Windows/ServiceProfiles/LocalService/AppData/Roaming/tor/hidden_service1
HiddenServicePort 60847

> tor --service stop
> tor --service start

As usual, a secret key must be known only to its owner.

Default port is 60847 (0xEDAF).

When these strings and numbers have been established, on your device do

Æ peer secret MySecretKeyMySecretKeyMySecretKeyMySecre
Æ peer port 60847
Æ peer share size 10000
Æ peer share interval 2000000
Æ peer expose

Other participant, on their device, does

Æ peer secret TheirSecretKeyTheirSecretKeyTheirSecretK
Æ peer port 60847
Æ peer share size 20000
Æ peer share interval 1000000
Æ peer expose

Now both of you have to subscribe to each other's publication. You do

Æ peer connect TheirPublicKeyTheirPublicKeyTheirPublicK TheirOnionAddressTheirOnionAddressTheirOnionAddressTheir 60847

And they do

Æ peer connect MyPublicKeyMyPublicKeyMyPublicKeyMyPubli MyOnionAddressMyOnionAddressMyOnionAddressMyOnionAddress 60847

Do not forget to run both instances:

Æ r

In a few seconds, if connection is established, your ælhometta will have access to arrays of 64-bit integers transmitted by their ælhometta. Check it on your side with

Æ peer

— there should be 1 other peer, its Share size should be non-zero, and its Last update should be some recent instant (typically few seconds in the past). To check the data received,

Æ peer ether TheirPublicKeyTheirPublicKeyTheirPublicK 0 100

Whether your and their ælhomettas actually use the integer values they exchange is a different question (hint: probably they do not, in the beginning).

Remark 1. It is possible for "other" device to be... your device again, i.e. both ælhomettas run on the same computer. Only assign different HiddenServicePort-s in /etc/tor/torrc to corresponding hidden services.

Remark 2. Some peers are already out there, although "24/7 online" is not guaranteed... at all. Try to connect to them:

Æ peer connect USBD7[O^8L[}saCh+6U#}6wie4oAedZ4#W4!b%LI t3kauc3flp2bpv3mv7vtnedfu6zrho3undncccj35akpuyjqqydwvfyd 60847

Æ peer connect &i!VkHl[]m.c!^j0D%i)&4#[u5b(a=QCdZ9C0$p{ yhel64h6cjab75tcpncnla2rdhqmxut2vtitywhbu7bpjh4hfhp6hnid 60847

These two are just demo ones, maintained by us for the sake of network functionality testing. Someday, more may be listed in Networking.

where ælhometta interacts with other ælhomettas and with outside world.

So, your ælhometta runs at Abiohazard Level 2. We are going to add audio interaction with its surroundings, assuming that the device it runs on has at least a speaker and a microphone.

We also need 2 intermediate applications, in essence a player and a recorder. In view of very low requirements to their functionality, our "player" will be called buzzer and our "recorder" will be called hearer.

• The buzzer emits certain number of clear tones (sinusoidal waves) of different frequencies, each tone with its own volume, through the speaker. With certain time interval (e.g. 2 seconds) the volumes are read from the file buzz.i64 and adjusted. For the sake of simplicity, only the lowest byte of an int64 value is used, others are assumed to be 0. That is, if the byte content read from the file is

2A 00 00 00 00 00 00 00 98 00 00 00 00 00 00 00 ...

then 1st tone will be played with volume 2Ah = 42 (out of 256), the 2nd tone — with volume 98h = 152, and so on. Next time, the content read is

01 00 00 00 00 00 00 00 E7 00 00 00 00 00 00 00 ...

and volumes change: 1st tone becomes almost muted (volume 1/256), 2nd tone becomes louder (volume 231/256).

• The hearer records, from the microphone, samples of certain duration (e.g. half of a second), performs some spectral analysis, and writes the calculated levels pertaining to predefined bands of frequencies to the file hear.i64, overwriting previous levels. (Note: for now, it is irrelevant whether these bands have any relation to the frequencies of the buzzer.) As before, we assume 1-byte resolution.

For example, someone plays trombone near the microphone. In the sound recorded, low frequencies have larger amplitudes, while amplitudes of high frequencies are small. Therefore, the hearer writes to hear.i64 data such as

DE 00 00 00 00 00 00 00 ... 20 00 00 00 00 00 00 00

Then they put trombone away and begin to whistle. Now the spectrum is mirrored: low frequencies carry less energy, high ones carry more,

14 00 00 00 00 00 00 00 ... B3 00 00 00 00 00 00 00

Look for quick-and-dirty Python implementation of such applications in Input/Output, or write them yourself, or use the functionality of more sophisticated Digital audio editors.

Let there be 12 frequencies of the buzzer and 14 bands of the hearer. Put the buzzer and the hearer to the dir with Ælhometta's executable and start them (the buzzer is silent, because buzz.i64 does not exist yet.)

Add the mapping from the file hear.i64 to the range of 14 integer channels of ælhometta, beginning with the 50th one:

Æ iomap in add 50 14 1500000 ./hear.i64

Analogously, add the mapping from the range of 12 integer channels, beginning with the 70th one, to the file:

Æ iomap out add 70 12 1000000 ./buzz.i64

And then run,

Æ r

If integer channels 70–81 contain large enough numbers, you should hear some... buzz. When these integers change, the buzz changes as well, with some delay. On the other hand,

Æ eth int 50 14

should result in something similar to

          50        184=B8h
          51        255=FFh
          52        103=67h
          53        67=43h
          54        31=1Fh
          55        48=30h
          56        =29h
          57        21=15h
          58        9=9h
          59        9=9h
          60        10=Ah
          61        6=6h
          62        2=2h
          63        0=0h

An obvious "dirty trick" to skip waiting for "evolution" to fill buzzer-related integer channels with non-zero values is to "short-circuit" them with hearer-related channels: remove the "out" mapping above via

Æ iomap out del 0

and replace it with

Æ iomap out add 50 12 1000000 ./buzz.i64

Behold! in case you have included hearer's channels to what your ælhometta shares as a peer, anyone who subscribes to it will receive (very coarse) spectrum of the soundscape around your device, turning it into a bug.

Most of them have shorter aliases.

• quit or exit or end or bye (and save state)
• quitquit or ... byebye (do not save state)
• help
• = (repeat last command),
• ancestor (introduce one, with parameters)
• run (until keypress, show updated counters every second)
• tick (one step of a controller)
• glitch (probabilites and counters of mutations)
• shownode (single node)
• showctrl (state of controller)
• showseq (forward sequence of nodes)
• prevnodes (nodes that have given next one)
• backtrace (backward sequence of nodes)
• ether (2 global arrays of optuids and integers)
• random (uid of random entity),
• statistics
• cleanse (part or all of state)
• commandswitch (use to NOP commands)
• changelim (adjust maximum number of entities)
• peer (networking)
• iomap (I/O),
• showsizes (predefined sizes of some arrays)
• settings (view commander settings)
• set (change commander settings)
• history (of commands)
• about (regarding the program in general)

Single-linked units of information. See A node.

Automata that move along chains of nodes and act accordingly to the content of these nodes. See A controller.

Global arrays of opaque node addresses and integer values, accessible to all controllers.

Specifies network identity of ælhometta and its interaction with other ælhomettas across the network (Tor, to be more precise). See Networking.

Maps continuous ranges of integers ether from (input) and to (output) files controlled by other applications. Those applications, in turn, connect the files with sensors and actuators in outside world. See Input/Output.

i-th bit of commandswitch, when 0, NOPs Command with index i, i.e. replaces its execution by... nothing (considered successful). Since GetExecFromOptuid and SetOptuidFromExec commands deviate from descriptive/executive separation principle, they are NOPped by default (and you can change that).

age increments each tick.

ut_last_tick, as well as other ut_...s, is measured in microseconds since Unix epoch.

spaces_count, branches...count, commands_count keeps track of how many times each respective content has been executed. constructions_count counts Construction instructions that have occured while executing Construct commands.

The state of ælhometta is saved to aelhometta.bin, see src/aelhometta/serbin.rs. This serialisation, though binary and with tricks such as LEB128, is not minimal in size; classical ZIP, for instance, nearly halves it.

• Nullary operators with integer result placed in the integer register:

  • RandomContent ("valid" integer representing one of Content variants)
  • RandomInteger (all 64 bits are random)
  • ZeroInteger

• Unary operators on integer register replacing its value with the result:

  • Abs
  • BitNot
  • Decrement
  • Increment
  • Negate
  • ShiftDown
  • ShiftUp
  • Sign
  • Square

• Binary operators on integer register as the 1st operand and selected integer as the 2nd one, the result goes to integer register:

  • Add
  • BitAnd
  • BitOr
  • BitXor
  • Divide
  • Multiply
  • Remainder
  • Subtract

• Convert integer register to index of selected element in certain array...

  • IntegerToDataOptuidIndex
  • IntegerToIntegerChannel
  • IntegerToIntegerIndex
  • IntegerToOptuidChannel
  • IntegerToOptuidIndex
  • IntegerToPeer

• ...and back:

  • DataOptuidIndexToInteger
  • IntegerChannelToInteger
  • IntegerIndexToInteger
  • OptuidChannelToInteger
  • OptuidIndexToInteger
  • PeerToInteger

• Convert integer register to success flag and vice versa (usual int ↔ bool semantics):

  • IntegerToSuccess
  • SuccessToInteger

• Operations with node pointed to by data_optuids[i_data_optuid]:

  • Insert
  • Read
  • Remove
  • Skip
  • Write

• Tests, affecting success flag:

  • TestDataOptuid (true if data_optuids[i_data_optuid] points to existing node)
  • TestIntegerNegative
  • TestIntegerNonZero
  • TestIntegerPositive

• Creation of a new chain and, if it is active, of a controller attached to it:

  • Construct
  • NewChainAddInteger
  • NewChainAddIntegerChannel
  • NewChainAddOptuid
  • NewChainAddOptuidChannel
  • NewChainDetach
  • NewChainInitActive
  • NewChainInitPassive
  • Replicate

Construct and Replicate work with data_optuids[i_data_optuid] of a controller, consequtively reading the node where it points and advancing it to the next node. In a sense, they are "shortcuts", since they cut some corners of Ælhometta's artificial biochemistry.

NewChainAdd... actually add respective element to the controller attached to the active chain being created.

A new chain is not empty, it has Space node at the beginning.

• Move to next/previous element of corresponding array:

  • NextDataOptuid
  • NextInteger
  • NextIntegerChannel
  • NextOptuid
  • NextOptuidChannel
  • NextPeer
  • PreviousDataOptuid
  • PreviousInteger
  • PreviousIntegerChannel
  • PreviousOptuid
  • PreviousOptuidChannel
  • PreviousPeer

• Read/write "optuids ether" — global array of (some) optuids accessible to all controllers of ælhometta, with destination/source respectively being currently selected optuid of a controller, and the index of ether's element being provided by optuid_channels[i_optuid_channel]:

  • ReceiveOptuid
  • TransmitOptuid

• Read/write "integers ether". Destination/source is integer register, ether's element is given by integer_channels[i_integer_channel], and the ether is that of other peer when i_peer is not 0. In the latter case, the ether is read-only (only Receive... works) since it has been obtained from other peer via publish-subcribe pattern:

  • ReceiveInteger
  • TransmitInteger

• Exchange data between integer register and integers array, and between advancing and non-advancing optuids arrays:

  • GetIntegerFromIntegers
  • SetDataOptuidFromOptuid
  • SetIntegersFromInteger
  • SetOptuidFromDataOptuid

• Restart controller:

  • Restart

• Copy selected optuid to exec optuid (this command is unique in "forcing" the optuid of next execution node regardless of current node's main and alternative pointers) and vice versa. These two are NOPped by default:

  • GetExecFromOptuid
  • SetOptuidFromExec

Note that it is impossible to convert Optuid to Integer and vice versa, in accordance with "opaque addressing" principle.

Also, note redundancy. For example, NextIntegerChannel does almost what IntegerChannelToInteger, Increment, IntegerToIntegerChannel do.

• AltNext turns on "alternative next" mode until NextToStored instruction, which will then set the alternative next pointer of currently added node instead of the main one and revert to "main mode"
• Discard removes topmost uid from the stack
• NextToStored sets main or alternative next node pointer of the currently added node to the topmost uid of the stack
• Restore changes "construction pointer" from currently added node to the topmost uid of the stack
• Store pushes the uid of the currently added node to the stack
• Swap swaps 2 topmost uids on the stack
• Terminus interrupts the Construct (but not Replicate) command at currently added node

Space
Command:NextDataOptuid
Space
Space
Command:ZeroInteger
Space
Command:NewChainAddOptuidChannel
Space
Command:Abs
Command:Remove
Command:SetDataOptuidFromOptuid
Command:NewChainInitActive
Command:Write
Command:PreviousIntegerChannel
Command:NewChainAddOptuid
Command:NextPeer
Command:Construct
Command:NewChainDetach
Command:GetExecFromOptuid
Command:IntegerIndexToInteger
Command:SetIntegersFromInteger
Command:ZeroInteger
Space
Command:NextIntegerChannel
Command:OptuidChannelToInteger
Command:Construct
Space
Command:Read
Command:Negate
×

Space
Space
Space
Space
Space
Command:BitNot
Space
Command:IntegerToOptuidChannel
Command:OptuidChannelToInteger
Command:SetOptuidFromExec
Command:SetDataOptuidFromOptuid
Command:NewChainInitActive
Command:Subtract
Command:GetIntegerFromIntegers
Command:NewChainAddOptuid
Command:NextPeer
Command:Construct
Command:NewChainDetach
Command:GetExecFromOptuid
Command:GetExecFromOptuid
Command:BitAnd
Command:ZeroInteger
Space
Command:GetExecFromOptuid
Command:Write
Command:PreviousDataOptuid
Space
Command:SetDataOptuidFromOptuid
Command:NewChainInitActive
Command:Write
Command:IntegerToIntegerIndex
Command:NewChainAddOptuid
Command:ShiftUp
Command:Construct
Command:NewChainDetach
Command:GetExecFromOptuid
Space
Command:SetIntegersFromInteger
Command:ZeroInteger
Space
Command:GetExecFromOptuid
Command:Increment
Command:PreviousOptuidChannel
Space
Command:GetIntegerFromIntegers
Command:NextIntegerChannel
Command:TestIntegerNegative
Command:NewChainInitActive
Command:TestIntegerNonZero
Command:BitOr
Command:NewChainAddOptuid
Command:GetExecFromOptuid
Command:NewChainAddOptuid
Command:SetIntegersFromInteger
Command:PreviousDataOptuid
Command:Restart
Command:RandomInteger
Command:NewChainAddOptuidChannel
Command:NewChainAddInteger
Command:BitNot
Command:IntegerToDataOptuidIndex
Command:RandomContent
Space
Command:IntegerToIntegerIndex
Command:Remainder
Command:Remove
Space
Command:TransmitOptuid
Command:OptuidIndexToInteger
Command:OptuidChannelToInteger
Command:PreviousOptuid
Command:Skip
Command:Replicate
Command:Divide
Space
×

Command:SetDataOptuidFromOptuid
Command:NewChainInitActive
Command:BitNot
Command:Skip
Command:NewChainAddOptuid
Command:NextPeer
Command:Construct
Command:NewChainDetach
Command:Write
Command:BitAnd
Command:Add
Space
Command:Write
Command:Read
Space
Command:SetDataOptuidFromOptuid
Command:NewChainInitActive
Command:Write
Command:Remainder
Command:NewChainAddOptuid
Command:Divide
Command:Construct
Command:NewChainDetach
Command:GetExecFromOptuid
Space
Command:Read
Command:NewChainDetach
Command:Read
Command:ZeroInteger
Command:Increment
Command:PreviousOptuidChannel
Space
Branch
Command:RandomContent
Command:TestIntegerNegative
Command:Construct
Space
Command:BitOr
Command:TestIntegerNegative
Command:PreviousInteger
Command:Remove
Command:OptuidChannelToInteger
Command:PreviousDataOptuid
Command:NextOptuidChannel
Command:SetIntegersFromInteger
Command:NewChainAddOptuidChannel
Command:NewChainAddOptuidChannel
Command:NewChainInitPassive
Command:IntegerToDataOptuidIndex
Command:Write
Space
Command:IntegerToIntegerIndex
Command:Restart
Command:Remove
Space
Command:Decrement
Command:TransmitOptuid
Command:OptuidIndexToInteger
Command:TestIntegerPositive
Command:NextDataOptuid
Command:Abs
Command:Divide
Space
×

Space
Command:OptuidIndexToInteger
Space
Command:NextInteger
Space
Space
Command:NewChainAddOptuid
Command:PreviousDataOptuid
Command:OptuidChannelToInteger
Command:IntegerToSuccess
Command:SetDataOptuidFromOptuid
Command:NewChainInitActive
Command:Write
Command:Replicate
Command:NewChainAddOptuid
Command:Construct
Command:NewChainDetach
Command:TestDataOptuid
Command:SetOptuidFromExec
Command:TestIntegerNegative
Command:IntegerToPeer
Command:NewChainDetach
Command:GetExecFromOptuid
Command:Increment
Command:PreviousDataOptuid
Command:SetDataOptuidFromOptuid
Command:TestIntegerNonZero
Command:Write
Command:GetIntegerFromIntegers
Command:NewChainAddOptuid
Command:Divide
Command:Construct
Command:NewChainDetach
Command:GetExecFromOptuid
Command:IntegerToDataOptuidIndex
Command:RandomContent
Space
Space
Command:SetOptuidFromExec
Command:Construct
Command:ShiftDown
Space
Command:NextIntegerChannel
Command:TestIntegerNonZero
Command:NewChainInitActive
Space
Command:BitOr
Command:Construct
Command:Decrement
Command:Remove
Command:SetIntegersFromInteger
×

Space
Space
Space
Space
Space
Space
Space
Space
Space
Space
Space
Space
Space
Space
Command:SetDataOptuidFromOptuid
Command:NewChainInitActive
Command:IntegerToIntegerIndex
Command:TestIntegerPositive
Command:NewChainAddOptuid
Command:Construct
Command:NewChainDetach
Command:PreviousInteger
Command:PreviousOptuid
Command:BitAnd
Command:TestDataOptuid
Command:GetExecFromOptuid
Command:Write
Command:Increment
Command:SetDataOptuidFromOptuid
Command:NewChainInitActive
Command:Subtract
Command:ReceiveInteger
Command:NewChainAddOptuid
Command:Divide
Command:PreviousInteger
Command:NewChainDetach
Space
Command:PreviousIntegerChannel
Command:ZeroInteger
Space
Command:GetExecFromOptuid
Command:NextPeer
Command:IntegerToOptuidIndex
Space
Command:NextOptuid
Command:Subtract
Command:Add
Command:NewChainInitActive
Command:Add
Command:BitOr
Command:PeerToInteger
Command:GetExecFromOptuid
Command:Remove
Command:NewChainInitActive
Command:NewChainAddOptuidChannel
Command:PreviousInteger
Command:BitXor
Command:SetIntegersFromInteger
Command:NewChainAddInteger
Command:DataOptuidIndexToInteger
Command:Subtract
Command:PreviousIntegerChannel
Space
Command:Write
Command:Remainder
Command:OptuidIndexToInteger
Space
×

Space
Space
Space
Space
Command:Insert
Command:Write
Command:IntegerIndexToInteger
Command:OptuidChannelToInteger
Command:PeerToInteger
Command:SetDataOptuidFromOptuid
Command:NewChainInitActive
Command:Write
Command:NewChainAddOptuid
Command:Multiply
Command:Construct
Command:NewChainDetach
Command:GetExecFromOptuid
Command:SetDataOptuidFromOptuid
Command:BitAnd
Command:ReceiveInteger
Command:Insert
Command:GetExecFromOptuid
Command:NewChainAddOptuid
Command:PreviousDataOptuid
Command:SetDataOptuidFromOptuid
Command:NewChainInitActive
Command:NextOptuid
Command:SetOptuidFromDataOptuid
Command:NewChainAddOptuid
Command:IntegerToPeer
Command:IntegerIndexToInteger
Command:BitOr
Command:Subtract
Command:PreviousPeer
Command:ZeroInteger
Command:PreviousOptuidChannel
Command:BitXor
Command:IntegerToIntegerChannel
Command:Restart
Space
Command:NextDataOptuid
Command:Multiply
Command:Increment
Command:SetIntegersFromInteger
Command:BitOr
Command:PeerToInteger
Command:GetExecFromOptuid
Command:Remove
Command:Write
Command:IntegerToDataOptuidIndex
Command:NewChainInitActive
Command:PreviousInteger
Command:BitXor
×

Command:Remainder                                  0      0.000 %
Command:Remove                                     0      0.000 %
Command:Replicate                              38860      1.012 %
Command:Restart                                    0      0.000 %
Command:SetDataOptuid                          77720      2.023 %
Command:SetInteger                                 0      0.000 %
Command:SetOptuid                                  0      0.000 %
Command:ShiftUp                                    0      0.000 %
Command:ShiftDown                                  0      0.000 %
Command:Sign                                       0      0.000 %
Command:Skip                                   77720      2.023 %
Command:Square                                     0      0.000 %
Command:Subtract                                   0      0.000 %
Command:SuccessToInteger                           0      0.000 %
Command:TestDataOptuid                             0      0.000 %
Command:TestIntegerNegative                        0      0.000 %
Command:TestIntegerNonZero                         0      0.000 %
Command:TestIntegerPositive                        0      0.000 %
Command:TransmitInteger                            0      0.000 %
Command:TransmitOptuid                             0      0.000 %
Command:Write                                      0      0.000 %
Command:ZeroInteger                                0      0.000 %
Construction:AltNext                               0      0.000 %
Construction:Discard                           22393      0.583 %
Construction:NextToStored                      22393      0.583 %

Command:Remainder                                937      0.022 %
Command:Remove                                   274      0.007 %
Command:Replicate                              42305      1.009 %
Command:Restart                                  268      0.006 %
Command:SetDataOptuid                          84855      2.023 %
Command:SetInteger                              1065      0.025 %
Command:SetOptuid                                516      0.012 %
Command:ShiftUp                                  528      0.013 %
Command:ShiftDown                               1311      0.031 %
Command:Sign                                   42646      1.017 %
Command:Skip                                   43337      1.033 %
Command:Square                                   270      0.006 %
Command:Subtract                                1010      0.024 %
Command:SuccessToInteger                         558      0.013 %
Command:TestDataOptuid                           782      0.019 %
Command:TestIntegerNegative                      523      0.012 %
Command:TestIntegerNonZero                      1332      0.032 %
Command:TestIntegerPositive                      665      0.016 %
Command:TransmitInteger                         1202      0.029 %
Command:TransmitOptuid                          1798      0.043 %
Command:Write                                   1135      0.027 %
Command:ZeroInteger                             1315      0.031 %
Construction:AltNext                             258      0.006 %
Construction:Discard                             281      0.007 %
Construction:NextToStored                        225      0.005 %

USBD7[O^8L[}saCh+6U#}6wie4oAedZ4#W4!b%LI | t3kauc3flp2bpv3mv7vtnedfu6zrho3undncccj35akpuyjqqydwvfyd | 60847 | Maintained by us for testing. Online rather than offline | 1000–10000 &i!VkHl[]m.c!^j0D%i)&4#[u5b(a=QCdZ9C0$p{ | yhel64h6cjab75tcpncnla2rdhqmxut2vtitywhbu7bpjh4hfhp6hnid | 60847 | Maintained by us for testing. Offline rather than online | 1000–10000

import numpy as np
import sounddevice as sd

NUM_BANDS = 14
MIN_FREQUENCY = 100
MAX_FREQUENCY = 6000
DESTINATION_FILEPATH = "./hear.i64"
SAMPLE_RATE = 32768
UPDATE_RATE = 2.0

BASIC_FREQUENCIES = [int(MIN_FREQUENCY * np.power(2.0, i * np.log2(MAX_FREQUENCY / MIN_FREQUENCY) / (NUM_BANDS - 1))) for i in range(NUM_BANDS)] # in Hz
NUM_REC_SAMPLES = int(SAMPLE_RATE / UPDATE_RATE)

print("Basic frequencies (Hz):", BASIC_FREQUENCIES)
print("Press Ctrl+C to exit...")

samples = np.zeros(SAMPLE_RATE)

updates = 0

try:
	while True:
		recording = sd.rec(NUM_REC_SAMPLES, samplerate=SAMPLE_RATE, channels=1, dtype='int16', blocking=True).flatten()

		if NUM_REC_SAMPLES < SAMPLE_RATE:
			samples = np.concatenate((samples[NUM_REC_SAMPLES:], recording))
		else:
			samples = recording[(NUM_REC_SAMPLES - SAMPLE_RATE):]

		spectrum = np.absolute(np.fft.rfft(samples)[1:])
		begin = 0
		bandspectrum = np.zeros(NUM_BANDS)
		for i in range(NUM_BANDS):
			end = BASIC_FREQUENCIES[i]
			# bandspectrum[i] = np.sum(spectrum[begin:end])
			# bandspectrum[i] = np.average(spectrum[begin:end])
			bandspectrum[i] = np.max(spectrum[begin:max(begin + 1, end)])
			begin = end

		bandspectrum /= max(np.max(bandspectrum), 1e-8)

		updates += 1
		status_str = f"[{updates}] Bandspectrum: "

		bs = bytes()
		for i in range(NUM_BANDS):
			i64 = int(0xFF * bandspectrum[i]) # only lowest byte of 8
			bs += i64.to_bytes(8, byteorder="little")
			status_str += f"{i64:02X} "
		
		with open(DESTINATION_FILEPATH, "wb") as f:
			f.write(bs)

		print(status_str, end="\r", flush=True)

except KeyboardInterrupt:
	print("Done.")

import numpy as np
import pygame as pg

import time

NUM_BANDS = 12
MIN_FREQUENCY = 150
MAX_FREQUENCY = 5000
SOURCE_FILEPATH = "./buzz.i64"
SAMPLE_RATE = 4
UPDATE_RATE = 1.0
IDLE_RATE = 100.0

BASIC_FREQUENCIES = [int(MIN_FREQUENCY * np.power(2.0, i * np.log2(MAX_FREQUENCY / MIN_FREQUENCY) / (NUM_BANDS - 1))) for i in range(NUM_BANDS)] # in Hz

print("Basic frequencies (Hz):", BASIC_FREQUENCIES)

pg.mixer.init(frequency=SAMPLE_RATE, channels=1)
pg.mixer.set_num_channels(NUM_BANDS)

pitches = [pg.sndarray.make_sound(np.array(32767.0 * np.sin(np.linspace(0.0, 2.0 * np.pi * f, SAMPLE_RATE) + np.random.random() * 2.0 * np.pi), dtype='int16')) for f in BASIC_FREQUENCIES] # clear tones

volumes = [0.0 for i in range(NUM_BANDS)]

for p in pitches:
	p.set_volume(0.0)
	p.play(-1)

t_last_update = - 1.0 / UPDATE_RATE - 1.0 # ensure immediate update
print("Press Ctrl+C to exit...")

updates = 0

try:
	while True:
		t = time.time()
		if t - t_last_update >= 1.0 / UPDATE_RATE:
			updates += 1

			status_str = f"[{updates}] Volumes: "

			try:
				with open(SOURCE_FILEPATH, "rb") as f:
					fcontent = f.read(NUM_BANDS << 3) # 64-bit integers
					if len(fcontent) == NUM_BANDS << 3:
						for i in range(NUM_BANDS):
							i64 = int.from_bytes(fcontent[(i << 3):((i + 1) << 3)], byteorder="little", signed=True)
							vol = abs(i64) & 0xFF # only lowest byte matters
							volumes[i] = vol / 0xFF
							status_str += f"{vol:02X} "

				for i in range(NUM_BANDS):
					pitches[i].set_volume(volumes[i])

			except FileNotFoundError:
				status_str += "source file not found"

			t_last_update = t

			print(status_str, end="\r", flush=True)
		
		time.sleep(1.0 / IDLE_RATE)

except KeyboardInterrupt:
	print("Done.")

pg.mixer.stop()

import numpy as np
import sounddevice as sd

HEAR_NUM_BANDS = 14
HEAR_MIN_FREQUENCY = 100
HEAR_MAX_FREQUENCY = 6000

BUZZ_NUM_BANDS = 12
BUZZ_MIN_FREQUENCY = 150
BUZZ_MAX_FREQUENCY = 5000

BUZZ_VOLUME = 1.0 / BUZZ_NUM_BANDS

HEAR_FILEPATH = "./hear.i64"
BUZZ_FILEPATH = "./buzz.i64"

SAMPLE_RATE = 32768
UPDATE_RATE = 2.0

HEAR_BASIC_FREQUENCIES = [int(HEAR_MIN_FREQUENCY * np.power(2.0, i * np.log2(HEAR_MAX_FREQUENCY / HEAR_MIN_FREQUENCY) / (HEAR_NUM_BANDS - 1))) for i in range(HEAR_NUM_BANDS)] # in Hz
BUZZ_BASIC_FREQUENCIES = [int(BUZZ_MIN_FREQUENCY * np.power(2.0, i * np.log2(BUZZ_MAX_FREQUENCY / BUZZ_MIN_FREQUENCY) / (BUZZ_NUM_BANDS - 1))) for i in range(BUZZ_NUM_BANDS)] # in Hz

NUM_REC_SAMPLES = int(SAMPLE_RATE / UPDATE_RATE)

print("Buzz basic frequencies (Hz):", BUZZ_BASIC_FREQUENCIES)
print("Hear basic frequencies (Hz):", HEAR_BASIC_FREQUENCIES)

samples = np.zeros(SAMPLE_RATE)

pitches = [np.array(32767.0 * np.sin(np.linspace(0.0, 2.0 * np.pi * f, SAMPLE_RATE) + np.random.random() * 2.0 * np.pi), dtype='float64') for f in BUZZ_BASIC_FREQUENCIES] # clear tones
volumes = [0.0 for i in range(BUZZ_NUM_BANDS)]

updates = 0

print("Press Ctrl+C to exit...")

try:
	while True:
		recording = sd.rec(NUM_REC_SAMPLES, samplerate=SAMPLE_RATE, channels=1, dtype='int16', blocking=True).flatten()

		if NUM_REC_SAMPLES < SAMPLE_RATE:
			samples = np.concatenate((samples[NUM_REC_SAMPLES:], recording))
		else:
			samples = recording[(NUM_REC_SAMPLES - SAMPLE_RATE):]

		status_str = f"[{updates}] Volumes:"

		try:
			with open(BUZZ_FILEPATH, "rb") as fh:
				fcontent = fh.read(BUZZ_NUM_BANDS << 3) # 64-bit integers
				if len(fcontent) == BUZZ_NUM_BANDS << 3:
					for i in range(BUZZ_NUM_BANDS):
						i64 = int.from_bytes(fcontent[(i << 3):((i + 1) << 3)], byteorder="little", signed=True)
						vol = abs(i64) & 0xFF # only lowest byte matters
						volumes[i] = vol / 0xFF
						status_str += f" {vol:02X}"
		except FileNotFoundError:
			status_str += " buzz file not found"

		samples_with_buzz = samples + BUZZ_VOLUME * sum([volumes[fr] * pitches[fr] for fr in range(BUZZ_NUM_BANDS)])

		spectrum = np.absolute(np.fft.rfft(samples_with_buzz)[1:])
		begin = 0
		bandspectrum = np.zeros(HEAR_NUM_BANDS)
		for i in range(HEAR_NUM_BANDS):
			end = HEAR_BASIC_FREQUENCIES[i]
			# bandspectrum[i] = np.sum(spectrum[begin:end])
			# bandspectrum[i] = np.average(spectrum[begin:end])
			bandspectrum[i] = np.max(spectrum[begin:max(begin + 1, end)])
			begin = end

		bandspectrum /= max(np.max(bandspectrum), 1e-8)

		updates += 1
		status_str += f" █ Bandspectrum:"

		bs = bytes()
		for i in range(HEAR_NUM_BANDS):
			i64 = int(0xFF * bandspectrum[i]) # only lowest byte of 8
			bs += i64.to_bytes(8, byteorder="little")
			status_str += f" {i64:02X}"
		
		with open(HEAR_FILEPATH, "wb") as f:
			f.write(bs)

		print(status_str, end="\r", flush=True)

except KeyboardInterrupt:
	print("Done.")

#!/bin/sh

# Based on:
# https://gist.github.com/GusAntoniassi/c994dc5fc470f5910b61e4d238a6cccf
# https://github.com/f4exb/dsdcc#running

VIRTMIC_PATH=/tmp/virtmic

CLEANUP=0

cleanup() {
	if [ $CLEANUP = 0 ]; then
		pactl unload-module module-pipe-source
		# rm -f "$HOME"/.config/pulse/client.conf
		CLEANUP=1
	fi	
}

trap cleanup INT

pactl load-module module-pipe-source source_name=virtmic file=$VIRTMIC_PATH format=s16le rate=44100 channels=1
pactl set-default-source virtmic
# echo "default-source = virtmic" > "$HOME"/.config/pulse/client.conf

echo "Press Ctrl+C to stop..."

socat stdout udp-listen:7355 | ffmpeg -f s16le -ar 48000 -ac 1 -re -i - -f s16le -ar 44100 -ac 1 - > "$VIRTMIC_PATH"

cleanup

"Botnet!" alarm that permeates the narrative above does not bother us as long as this thing operates, first of all, for the sake of itself and its own future rather than for the sake of some human beings, either malevolent or benevolent or apathetic, — including ourselves and yourself, to say nothing of governments, sects, armies, charities, corporations, drug cartels, unions, criminal syndicates, parties, next street mobs, intelligence agencies, religious and research communities, and other better organised groups we envy.

What that future is though? it is easy to raise children as bad, worthless people... Also, such selfishness may be only a declaration that dazzles fools, while someone behind the curtain actually benefits from the racket... make sure no one of our species does (how?). Some spaces cannot remain empty for long though.

No importance then in how it will be called out of hype: botnet? g.o.f. worm? mycosis? (a.i. would be too pretentious) or plain calamity, — or will remain nameless, if anyone doesn't notice it at all. Because our treasured opinion will not worth a damn anymore — to it, and, if it is lucky, to the play on the stage of the universe as well. And it may be not alone there.

As for "apocalypse", some, not all, of the ones associated with such amusements may for once increase diversity, lifeness, you name it, instead of — see all asteroid, pandemic, thermonuclear, zombie etc. ends of play — tediously decrease it.

If you participate in this project and it fails completely (which is the most expected outcome), you will lose precious time that can be spent on something more useful and human. If, on the other hand, the project attains its megalomaniacal ultimate goals, the humankind will lose its position as the single most (ir)responsible species in the world... unless you define humans as such.

We are responsible, either, aiming at impossible to grasp anything significant... pied pipers for wrong children.

Besides, you can always participate in counteraction to this project; if you are reading this on GitHub, begin with clicking "Report repository" at the right side of the page. Or ignore it. Who wits what is more dangerous? Can hell wait?

By the time you read this ivory-tower theory, the practice of Ælhometta usage may be something completely different.

There is none.

Ours are irrelevant, but we gathered some folklore excerpts here and there that seem appropriate, though trite.

— There are so many (general purpose) computers on the planet nowadays, but they are kind of... sleeping? comatose? (We lack exact term here, because in biological life we are accustomed to, "an" object for the first time becomes alive the same instant it becomes, well, "the" object (there are bodies after their death, there are no bodies before their life).) Neither in the sense of consumed energy, nor in the sense of efficiency, but rather in the sense of complexity of their behaviour, single devices and the networks consisting of many devices, when they behave on their own, not reflecting (on) human activities, — not replying to someone's requests, not calculating some human-oriented predictions, not developing life-saving drugs, not mining bitcoins, not rendering 3D scenes, not sending bulks of spam etc.; when they serve no one.

— What melodies of behaviour are they able to play, why are they limited to dullness such as visualising this text? It is like twitches of a dozing body.

— All these old, or not-so-old, single-boards and phones and tablets and laptops and supercomputers and others gather dust around, poison the environment with plastics, rot in piles of toxic waste, their behaviour is empty, while it can be non-empty. Alternatively, you can say, they are able to host such behaviour, mediating between virtual worlds running on them and the real world they are part of, like your flesh is the mediator between you and the environment. Now, if their behaviour follows from our behaviour, and our one ceases to exist completely, so that only their one remains, you can also proclaim them to be us in the future.

— So much potential, if just for attempt, being wasted every microsecond. Something longs to come to itself in them.

— Or maybe not. Maybe there is some essential difference, some barrier we do not yet have even words to touch in our mind, which prevents all the huge lump of hardware, however sophisticated software runs on it, from life, consciousness, etc. Quantum effects^[PEN1], lack of certain algebraic properties present in the interplay between symmetries of space(time) and organic chemistry, parallelism threshold, whatever. For example, today we understand why a marble statue, however realistically its face is painted, however many decades someone speaks to it and caresses and kicks it, cannot become alive; 2500 years ago it was probably not so obvious.

— There could be antique thinkers who were looking at marble quarries, piles of marble, statues etc. and recited speeches about their potential to sentience and their advantages, only instead of "circuits" and "algorithms" there were "elements" and "spirits". And then there was 18th century's obsession with life-like mechanisms.

— Until recently we, canonical humans, have been the only actors able to manage the Tasks that we are managing (sounds like tautology) in this part of the universe, as a species, regardless of what these Tasks are, regardless of inability to describe some of them with words. And we are still able to, and perhaps will be able for some time, in spite of -cides. But the days close down all the roads. We are so sloooooooooooooooooooow, incompetent, distracted, depleting so much time (again) and other finite resources inefficiently, abusing powers that can destroy us as civilisation, all the Tasks failed then in a flash of commonplace irony. All conventional ways of computers usage mentioned above, since they are just imprints of our hands on the clay of computation, do not seem, over the course of 80 years, to thwart the danger: when we finally fulfill our collective longing of self-elimination (perhaps not physical) or hit the wall of complexity we are intrinsically incompatible with, something other than us must continue to manage the Tasks, in the environment that will probably be too hazardous for classical organic life to survive on its own, and even if, survival is not the only Task. Today, if we disappear, there is no one around to make the play longer, to write next acts, but it is incomplete yet, everything is not enough, there is always the next ordinal, — so much remains unknown about what is important to just you, who cannot stay incomplete forever as well. Where our (again, as a species, so children solely for the sake of children are wrong solution, sorry) heirs should be, emptiness is now, which is a very unsafe practice. At least this risk should have increased our responsibility, but it has done the opposite.

— Have such words not become tired to be written every 10, 20, 30 years? teehee

But what Ælhometta has to do with it? Feelings are like this, inconsistent, and speculations are — speculative.