Created

Since being a child I have been wondering about information distribution, feeling inefficient.
This page reflects on how to build it.

Towards spirit stream

Direction

Distant next version

More refined

Spirit Stream

When I follow curiosity, leaning into my wonder about computer and internet, I sense dissolution: The edges of my body fade and I float through the associations between all possible spaces. Into the space, through trees, stories, videogames, temples, beauty, destruction. I see my questions answered, not definitively, but as completely as the collective mind can. I sense connection, trusting and deep. I sense the conflicts in the world as internal, not as foggy, distant pain. There are no external barriers to my being and I stream into others to see exactly what they mean. And in my action, the structure of the world, not merely my individual life, is reflected.
Returning to my body, I can't help but wonder what the fuck this is: Me, stopping with my fingertips, not being able to walk through walls, facing the endless world in mist asking hello with no answer.

Floating head, slightly tilted. Partly shaded, mask-like. Reminiscent of a skull. Dark background and dark lines across the white head, partly messy, decorative and minimally defining facial features. Closer eye is white, further eye is black. Red-magenta lines overlay the skull, partly straight and splitting the image, partly squiggly.
Spirit of curiosity
i can see the hive mind on the horizon.
there are hammers, sculptors, hammer blows and sculptures.
grouped and isolated
places to stay.

like gazing into a painting, being guided through the impression
coming along to find a question asked at myself, seeing it unfold and building a response

Computers, able to execute practically any function;
AI, approximating more complex functions;
Internet, being a global, instant post office;

The spirits, seeking continuity with the environment and particularly the spirit of curiosity are calling towards internalizing these technologies.

The spirit stream aims to become the passage into the machine.
It will have to be able to contain me and respond in its own spirit.

Me, to be reflected in the machine:

Sense, explore, parse circling patterns from
chaotic and far-reaching,
through filtered and coherent knowledge,
to linearized, actionable and accessible stories.

Express in sound, body,
writing, graphs, images, products,
and any tools to build them,
in process,
from memory.

Share in truth,
to test, be surprised, dance, reproduce, join the cutting edge, offer, cohere, support, punish,
into common languages per context,
into scopes of recipients,
under optional conditions.

Where I am,
When I am.

The target:

Executors of machine code within instruction sets,
of functions, programs, function approximators compiled from many languages,
from and to memory.

Expressing in any electronic actuator,
speaker, display, motor.
Receiving from any electronic sensor,
keyboard, mouse, camera, microphone

Exchange anything at up to ~storage speeds,
through ports, through fundamentally unreliable, insecure connections,
to any available address,
made reliable, secure through protocol and application server

Less refined

How to merge?

Is there a throughput problem and must I build the neural interface? I suspect not, as sometimes simple words or images speak so loudly and clearly, throwing open the doors to the world with their precision and closeness. If the interface becomes seamless, reflective of the user, and the spirits of computer and internet reveal themselves, there is no difference between the machine and the body. When I can speak with clarity and my computer extension answers with clarity, we merge.

Synchrozined web servers, always available through any browser, locally and worldwide.
Exportable to physical and persistent formats
Authenticate to full access
Editor to place symbols into any language to manifest patterns. On display, symbols are rendered into the images they represent.
Within a single column, wrapping to fill the screen
In different areas of refinement, On different sites, linked.
To be committed to history and/or streamed.

Commit history is a timeline to comment on.
Receive general messages through email

Introspection for access logs and performance review.

To discover and be discovered, search engines, LLM pretraining or dynamic research through an LLM seem sufficient. There is limited upside to being connected to everyone, as on X, and most lasting connections still seem happen through reference by already known people, not through the algorithm.
Algorithms are able to interact in the same ways as me -> UI connects to API.

Currently implemented structure

Writing in pure html, css, javascript: VS Code, prerendering to static sites locally (table of contents): node.js
keeping history in a git repository,
Sent to remote server: Hetzner VPS: OpenSSH, nginx (HTTP, HTTPS),
Reachable through Cloudflare DNS

OS

OSDev Barebones and preliminary notes

Seeking a seamless, harmonic human-machine interface leads me down to operating systems, where the machine is met and negotiated with. Seeing no need to go deeper until this layer is great. Meet the machine. OSDev.org

The OS is first developed for only one target machine. Relevant components:

  • Asus Z270E mainboard
  • Intel 7700k processor
  • SATA HDDs and SSD, M.2 SSD
  • 3860x2160 monitor via display port
  • USB mouse and keyboard
  • Headphones via line out

  • Bare Bones reinterprets the Bare Bones tutorial on OSDev.org for my usecase, shortening some and expanding on other concepts that seem fundamentally important.

Bare Bones

How to launch the OS? ESP with bootloader+kernel

When the computer starts (power button shorts two mainboard pins), the mainboard firmware, following the widespread UEFI standard initializes connected hardware and, for each storage device, looks for partitions (separately managed storage parts) that are EFI System Partitions (ESP).
UEFI supports some MBR and GPT partition table schemes [1]. It contains bootloaders: .efi files made to hand control from the firmware to the OS kernel (central program in the OS, responsible for ressource allocation and sys calls etc.). The reason bootloaders exist i In some configurable order, UEFI tries launching bootloaders until one works. The bootloader

  • determines which partition to boot from
  • finds the kernel in the partition and loads it into memory
  • sets up the environment: stack allocation, protected mode
  • hands control to the kernel, passing any necessary parameters to it

Bare Bones bootloader (GRUB), gluecode and kernel

GRUB is a magic bootloader that does everything for me and follows the Multiboot Standard when finding and handing control to the kernel. This means the kernel 1. needs a multiboot header and 2. is left to set up the stack itself. This first kernel part is written in assembly, because compiled C already requires a stack to run.

/* boot.s: minimal assembly to launch the kernel,
    compiled using GAS to boot.o
    Bare Bones Boostrap Assembly includes detailed comments */
    .set ALIGN,    1<<0      
    .set MEMINFO,  1<<1      
    .set FLAGS,    ALIGN | MEMINFO 
    .set MAGIC,    0x1BADB002      
    .set CHECKSUM, -(MAGIC + FLAGS)
    
    .section .multiboot
    .align 4
    .long MAGIC
    .long FLAGS
    .long CHECKSUM
    
    .section .bss
    .align 16
    stack_bottom:
    .skip 16384 # 16 KiB
    stack_top:
    
    .section .text
    .global _start
    .type _start, @function
    _start:
        mov $stack_top, %esp
        call kernel_main
        cli
    1:	hlt
        jmp 1b
    .size _start, . - _start

The kernel in Bare Bones, written in C, only uses the VGA text mode buffer presumtively set up by GRUB to display text on the screen.
It does this without the C standard library, which is unavailable because it would require 1. system calls and dynamic linker support already implemented in the kernel, and 2. the linker and library available at runtime. This is called being in a Freestanding Environment as opposed to a Hosted Environment. Some header files, though, are part of the compiler, not the C standard library, so some data types, contants and macros are still available.

To compile the kernel, a GCC cross compiler is used.

/* Kernel code without abstractions.
    There is a VGA text mode framebuffer at address 0xB8000.
    It starts by writing spaces with black background color into the whole buffer:
    foreground color (4 bits), background color (4 bits), character (8 bits).
    If white is 15 and black is 0*/
    
    // INSERT HERE AFTER TESTING

Intel integrated graphics driver

Intel Docs

Text editor

Initial thoughts towards C+OpenGL text editor

The world is open when I can understand and create my own infrastructure. I will own my environment and can test how far I can merge with the machine. Start with C+OpenGL text editor compiled to web. C+OpenGL because they are low level (offer insight) and extremely widely supported.

  • Write fira code ttf into an infinite column
  • display line numbers
  • scrolling
  • cursor control with keys and mouse

Setup

OpenGL is a language to talk to the GPU to efficiently produce graphical output. It's implemented by the graphics card vendors. How to use OpenGL

To open a window and handle input, talking to the OS is necessary. Possible to do manually, but using GLFW here.
Compile GLFW with CMake. In my case, compiled for wayland only - could possibly be simpler to compile to WASM. Then copy include folder and libglfw3.a from build/src/ to project-folder-include and -lib respectively.

Same article goes into GLEW. Download, run make in the directory, copy contents from lib and include to project folder.

OpenGL already installed on Ubuntu Linux, but dev tools help: sudo apt-get install libglu1-mesa-dev.

main.c to get OpenGL working and test it

#define GLEW_STATIC
#include 
#include 
#include 

int main() {
    glfwInit();

    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);

    glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);

    GLFWwindow* window = glfwCreateWindow(800, 600, "OpenGL", NULL, NULL);
    glfwMakeContextCurrent(window);

    glewExperimental = GL_TRUE;
    glewInit();

    // Testing only: output should print 1
    GLuint vertexBuffer;
    glGenBuffers(1, &vertexBuffer);
    printf("%u\n", vertexBuffer);
    
    while(!glfwWindowShouldClose(window))
    {
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    glfwTerminate();
    return 0;
}

Convention says to put main.c into src/ of project folder and the compiled output into build/. Compiling with: clang -I ./include/ src/main.c -L ./lib/ -lGLEW -lglfw3 -lGL -lGLU -lm -o build/main

Compiling freetype2 to render true type fonts. Compiled from source with ./configure --enable-static --disable-shared --with-png=yes CFLAGS="-static" and make. Then adding the -lpng -lz -lbrotlidec -lfreetype compiler flags.

OpenGL

It forces a framework onto graphics. Rendering a scene, it goes through a given graphics pipeline, first determining the shape, rasterizing it and calculating color. Programs for each step are called shaders. Minimum two shaders must be user specified: 1. Vertex shader: can manipulate vertices dependent on frame in an efficient way without requiring to alter the original geometry. 2. Fragment shader

Vertex Input

vertices = array of numbers -1.0 to 1.0 (outside those bounds is discarded) later to be interpreted as series of x,y,z coordinates of points, usually points of a triangle.

Vertex Buffer Objects (VBOs) help with sending the data to the GPU. Bufferse are generated using a function (which assings an ID toO). One Buffer can be bound at any time to any buffer type so all functions manipulating that buffer type will apply to the bound buffer. eg: glBufferData(buffer type, size, vertices, memory optimization) applies to the buffer current bound to [buffer type]

Vertex shader

minmal shader, not modifying coordinates specifies version used, an input 3D vector (x,y,z), main function and assigns the input to gl_Position (opengl's 4D output vector) with the fourth component set to 1.0 because who knows what it is.

Compiling a shader

Shader is loaded as single string, assigned to shader object (GL_VERTEX_SHADER in this case) compiled through a given opengl function (gLCompileShader)

Shaders are compile at runtime. Original article at this point explains how to log shader compilation errors.

Fragment shader

Fragment = pixel (discrete part of a scene). Calculates color. Same otherwise.

Shader program

Will make the still separate vertex- and fragment shaders work, linking their in- and outputs accordingly.

After program creation, the separate shaders are not needed anymore. glUseProgram([shaderProgram]) will make any following shader/render call use it.

Linking vertex attriutes

how to interpret the vertex input? for which location (specified in vertex shader) is the data? how many values? what type? what stride? start reading the buffer with an offset?

Editor design

  1. initial usage: ss [path]
  2. Load file into RAM
  3. Get character set
  4. render glyph atlas
  5. split text into words (line breaks)
  6. write words that fit into the line (monospace). If word longer than line, split without hyphen

Apple TrueType docs
microsoft OpenType docs

SFTP

Notes upon partial reading of SSH specification

SSH

Secure network sevices through insecure network. On top of secured transport layer, like after TCP handshake.

RFC 4250 contains assignments of codes for different messages / symbolic names.

SSH-ARCH (RFC 4251)
  • SSH-TRANS: Transport Layer Protocol: server authentication, confidentiality, integrity, optional compression. derives unique session id
  • SSH-USERAUTH: Client authentication
  • SSH-CONNECT: Tunnel multiplexed into channels

Host keys identify the host. Known apriori or verified through a certification authority (CA). Allow storing identity after first connect = vulnerable to Man-in-the-middle-attacks. Warn if the host key changes in the future.

Specification gives some algorithms, but different ones can be used on per-domain basis. I can specify in configuration:

  • choice of algorithm for encryption, integrity, compression and public key
  • method for key exchange for host authentication.
  • required authentication methods per user, may require multiple
  • permitted actions by user. Server cannot run commands on client and no connections to authentication agent

Specify encoding for protocol data, mostly UTF-8. For terminal session data, encoding is inferred from terminal emulation type. internal names in US_ASCII. client and server names in ISO 10646 UTF-8. Recommend bit-wise comparison.

Text messages (errors, debug, config data...). send codes instead, other messages should be configurable.

Data types:

  • raw bytes
  • bool (1B). o (false) or 1 (true). >1 = true but not allowed.
  • uint32, uint64(4B, 8B, decreasing signficance)
  • string (uint32 stores length, then 0 or more bytes with the actual content: no null-termination).
  • mpint (numbers, but stored likes strings (with length being the first byte). two's complement. if first bit is 1, then precede with a 0 byte)
  • name-list (string, comma separated names (no comma in names!), US_ASCI!)

Algorithm and Method Naming (Refer to this because very specific error checking)

RNG, RFC 4086Provides some guidance.

Control Character Filtering - Replace control characteres when displaying.

other

database

ANSI codes

llms contain linguistic maps. they can draw the landscape for me if they know my maps too.
a language model that has not learned to answer questions tells stories.

Karpathys ideal blogging platform
file over app

"lazy payment" - unrealized costs become realized when someone pays transaction costs? optionally anonymously.
payment + PAYG
wikipedia
tor
interplanetary file system

disqus
discord
plausible analytics
atom/rss
C preprocessor

"Digital gardens"
https://github.com/MaggieAppleton/digital-gardeners
https://simonewebdesign.it/

markdeep
libh2o PowerDNS.org with nice articles

non-hierarchical file system.
bytes, pointers -> pointers are bytes too and can store tags for their bytes.
files, tags. Tags are files too. So, structure defined by links.
How to navigate it?
design an entry point
Graph view is useless.
search files by how they are connected.
tags are unnecessary, they are literally a weak link
navigate through forward and backward links.
optionally select an overlap of multiple links. like ctrl-click to add to the group which must overlap.
the backlink that I come from should be highlighted
Information becomes hierarchically organized as it matures. No problem. Hierachy is a subset of this system.
converting from hierarchy is easy. converting to hierarchy requires disambiguation: which link(s) should become the files folder(s)? Mutltiple folders means the file is copied.
drives are tags.
branches are tags.
git gives UI for merging files and tags, like from pull requests or other branches.
how to limit number of forward links while maintaining their precision? display them as searchable list. searchable also for overlap.

P2P streaming with relay nodes

messages are files automatically received and that I actively send out.
can be (are) grouped under tags depending on sender.

Taken hierarchy path forward links, some external
backlinks broken links

https://explained-from-first-principles.com/internet/#out-of-order-delivery

messages understood through the protocol
handle unexpected response, ask for retransmission, time out if silent, maintain order of messages, account for latency.

5 layers

  1. link:
    addressing using MAC address within a network through ethernet, wifi, bluetooth protocols. maximum transmission unit (MTU) = how many bits in one package max.

  2. network layer
    uses ip address to connect between different networks through the Internet Protocol (IP). routers send error messages and other information about itself using ICMP (internet control message p)

  3. transport layer
    os sending/receiving stuff to/from to processes running in the OS. uses port numbers to differentiate. a process that exists to respond is called server, one initiating the connection is called client.
    can use transmission control p (TCP). pretends there is a direct connection (not packets). enumerates, buffers and confirms received messages to put into right order, retransmit or request retransmission if no confirmation was received. uses checksum for ensuring reliability. sender slows down if it gets no feedback (how is this part of the protocol?). tcp handshake before actual payload transfer sets a random starting point for the enumeration, making it hard for randos to impersonate senders (attackers must now guess correctly to enter a ongoing chat)
    user datagram p (UDP) fast, unreliable connectionless transport. only source, destination ports, length and checksum in header. streaming!

  4. Security layer

VS Code for UI. Destroys WYSIWYG. CSS is the visual vocabulary for html. html is pure semantics and its independence from style give nice flexibility. WYSIWYG not needed? Complicated, extendable editor like VS Code seems like good design. Who knows what and how people want to edit. Best editor is a tool to build your own editor?

The things I know appear so simple, so efficiently encoded. Like how to make rice. But trying to explain it in its entirety, I watch in pain, as I require many words to capture it even approximately.

History

List of git commits, with commit message, changed files, link to the repository state of that commit, view diff (technical) or site (html). Files and repo are downloadable. Should be close to a casual timeline while keeping access to more technical information.

Server api:
api/commit=[commit];blob=[blob];diff=true: render diff to previous commit into html in a code block
api/commit=[commit];blob=[blob];site=true: get blob site. all links (html, css, js) are resolved to their blob sites
api/blob=[blob]: get blob

2025 01 30

Full web access maybe not practical because browser fundamentally distrusts servers and so blocks interaction with local files. The spirit stream would be trusted locally, communicating with a remote, untrusted server.
End-to-end encryption would require storing the key clientside while making it accessible to the page's javascript. Synchronizing files seamlessly is impossible.

-> Build a trusted client where I can produce, commit, encrypt/decrypt and sync files. Available for desktop and mobile.
C+OpenGL because it's low level, so easy to dive deep and understand everything, clean, widely supported and portable.

Client:

Make a trusted, local server instead that can:

2025 01 31

Since I construct meaning from the individual, I view all higher structures of power (groups, communes, cities, states, religions) as a service to the individual. This is how they are justified and how they ought to be kept in check. When merging with the machine, building it from the individual is critical to avoid top-down dominance.

Become a device -> Become remote devices through the network
Build a machine, make it work. Put the world into it, authenticate to make extension optional and not excessive. Authenticate through the network into more machines.

2024 01 31

I want to know how to use the computer but don't want to learn it. Move windows where I want them. Camera, live video. publish button on files. showing me their status. stupid file system, what if it would be tags? Sync with phone. extremely easy to use desktop and mobile apps. talk to the computer. have it accompany me. make suggestions about where to go.have someone I can talk to, that understands me. that can help me. that i trust. I am in control. Contain my memories, easily shared. my notes. everywhere. can the site be a portal for otheres to join in too? where i am live more often. doing what i like to do. others doing their stuff. people gaining reputation. workshop, bar. where people can visit. screens are large and immersive and they are places that I can take people to.
I don't want to be alone. are there not places to go, to build? where the places invite me in?
Lots of writing only happens in interaction with others. someone I am writing to, that I know, where I will elaborate. I will not elaborate just for myself.
Is the spirit stream even possible if it does not involve physical proximity? online rooms. part of the appeal of working in the garden where I lived before was I would be able to show it to other people. not like showing off but spend time there, use it as a space to share. Online doesn't work that way. and who would join me anyway? its like impossible. maybe the best thing to do is literally join the townsquare and talk my way into the world. Get to know people through reference, not through them visiting my site randomly and deciding to join a space there (never gonna happen). Is there no such thing? Is there only being highly valuable and being of value to people. Experience says otherwise. WTF is this. where is the world?

2025 02 03

1. OS

At the bottom of the spirit stream is the operating system. my attempts to write my own text editor and SSH client lead nowhere. Executors of machine code within instructions sets is the true foundation for the spirit stream. No need to go deeper.

Why OS? To meet the computer and let higher structures fall into their place. How to build OS?

2.

Maybe merging physical and virtual world means replicating my room in the computer and the computer in the room. Most of the room is static -> low network load; focus on moving and important parts instead: Faces. Computer should compress data by "scanning" environment and face and storing/transmit itting transformations to save space.