Created

I have been wondering about information distribution, feeling inefficient.
This page reflects on how to build a seemless, integrated information structure for it, and this repo is where it's built.

Towards spirit stream

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, farther 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

There seems to be a structure behind notes, memes, essays, books, stories, exhibitions, spaces, products, worlds. They consists of simple patterns in the mind, which I characterize like this:

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.

If the process can be reflected in the machine, the patterns and me with them can seamlessly enter the machine and the its abilities...

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

Store, retrieve anything, persistently, quickly

Express in any electric actuator, speaker, display, motor.
Receiving from any electric sensor, keyboard, mouse, camera, microphone

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

...become my own. The spiritstream aims to be the passage into the machine.

How to merge?

Since I construct meaning from the individual, I view all higher structures of power (groups, communes, cities, states, religions) as services to the individual. Build free, accessible, independent, private, no login, no lock in.

The flow of patterns in the mind precedes common language and translating it shrinks and distorts them. A direct neural interface may simplify the process. An AI could interpret the stream and seamlessly induce useful patterns. Should I now try and build a neural interface?
I suspect not. The patterns are repetitive and I have seen myself expressed in words almost entirely. Simple words or images can speak so loudly and clearly, throwing open the doors to the world with their precision and closeness. Finally, the problem of organizing symbols - patterns or words - remains. The neural interface may follow.
When the interface becomes seamless and reflective of the user,
when the spirits of computer and internet reveal themselves,
when I speak with clarity and then extension answers with clarity - we merge.

Create, reuse, organize and share arbitrary symbols in 3D space, which is the most dimensions I can understand and use intuitively. Links to other spaces enable arbitrarily many dimensions.
Remember a continuous stream of actions to provide a seamless safety net and past data to learn from. It encourages revisiting instead of starting anew, improving quality, and allowing fearless, even reckless editing.

Eventually, the spiritstream becomes the primary interface to the computer, an operating system. Motivation for depth and vertical integration is meet the computer and let higher structures fall into their place. Assume hardware is good + it's expensive to build -> don't go into hardware until software is insanely great.
Initially, it's a desktop client using python, OpenGL and GLFW to refine abstractions before setting them into C and becoming standalone.

Synchronizes with untrusted remote servers. Uses end-to-end encryption for non-public data. Public data is available in the web view.

To discover and be discovered, search engines, LLM pretraining or dynamic research through an LLM seem sufficient.
Algorithms and humans have equal capability when interacting with the spiritstream: A local or remote server handles all file modifications, while a trusted client is the interface.

Current process for publishing:

Writing in pure html, css, javascript: VS Code, prerendering to static sites locally (table of contents): node.js
keeping history in a git repository,
Synchronizing with remote server over SFTP using python paramiko: Hetzner VPS: OpenSSH, nginx (HTTP, HTTPS)
Discoverable through Cloudlfare DNS.

Less refined

Editor

Create and place symbols into sequences
use markdown interface for common formatting and differentiating semantic blocks
Blocks are styled using CSS
position into 3D space (x, y, z, rx, ry, rz)

Clicking on nodes always selects the first deepest node in the tree. This makes layers a direct translation of the tree. It's also inverted, so the deepest nodes are the top layers.
Hold space and drag to move. Shift select other frames too.
EDIT MODE: Double click to edit, ESC to exit. Scroll in all directions. Shift scroll for horizontal scrolling, ctrl+scroll for zooming.

Views:
Strict WYSIWYG necessitates a preview, without any UI hints.
Edit (Markdown mode): view formatting syntax only for selected nodes, comments are visible.
Source: full formatting syntax, html.
3 Views: how to reduce?

The piecechain stores everything. There is no monolithic starting piece, only a big append only buffer. It stores the serialized node tree, which the render tree is built from. When assembled, it's a JSON file.

Tree of nodes.
Node(x, y, z, rx, ry, rz, w, h, style)
Scene(title, camera, children). Camera (x, y, z, rx, ry, rz, fov)

Links:
may be GO or SHOW, either displaying a "door" to the data or embedding the data in its place.
Links reference piece indices. This requires updating all links when pieces are inserted before their target. SHOW links have start and end node and display everything inbetween. If either node is deleted, notify user / show hints for backlinks next to start pieces / for cursor position. SHOW links require META interaction to change the linked content but show no difference in preview mode.

Log

Continuously store individual, reversible actions. Data is not included but referenced to improve performance. Piece chain with algorithm to merge / redistribute pieces occasionally.
Rerun history against past states for integrity check.
Self optimizing cache for past states. 

file structure:

The log can store write, erase, seek (time/file+cursor) and meta (non-essential)

Upon loading, the log checks integrity and adjusts to any unrecorded changes:
- get latest view according to log file
- get difference to home files
- log events to catch up with home files.

class Log:
    def __init__(self, filepath):
        """Initialize log with the given file path."""

    def write(self, text, cursor=None, author=None):
        """Insert text at cursor."""

    def erase(self, count, cursor=None, author=None):
        """Remove count characters at cursor."""

    def save(self):
        """Save changes to the log."""
    
    def view(self, date):
        """Return the state as of the given date, without altering current state."""
    
    # internal methods
    def _seek(self, position):
        """Record a seek event if cursor position changes."""

    def _meta(self, **kwargs):
        """Record a meta event storing keys and values like user:alice or comment:"hamedi is coming for you" """

    def _elapsed(self, seconds):
        """Record elapsed time since last event."""

File system

1D sequence of data. Higher dimensions are represented through pointers/links. Places pointing to other places. Start at entry point or last position. Fuzzysearch by link name(s) that must be associated with a given search target. Choose whether to consider each link bidirectional or not.
Example: "page, hamedi" searches for all content that is associated with "page" and "hamedi", where "page" may not be more than an empty link target to enable differentiation in searches like this, like tags.

Delete, copy, rename are meta: they don't modify the link but the data it points to. Delete is the same as removing all references to a piece of data, gives warning when deleting last reference.

Filesnames don't have to be unique.

Privacy map informs client what to en-/decrypt and server what to send. Akin to datatypes.
determines which piece indices / range require authentication / decryption. Necessitates splitting pieces at privacy rule perimeters. A privacy rule is a WHITE or BLACK list. Empty blacklist = public. Empty whitelist = private. Should be able to reuse privacy groups.

To maintain links, the offset they point to must be updated. To minimize updates, organize in a binary tree with offsets on each node and relative to parent node. Bytes at the bottom. Can either point to (GO) or include (SHOW) piece index / range. Any display is SHOW links. Any UI is SHOW links. Can contain nested SHOW links. Editing content necessitates visiting the original. My location is defined as where my edits write directly to file, no META.
SHOW links just show content somewhere else. Linking to it, formatting it as a quote is optional, must be explicit. Pasting files pastes a GO link to the file.

Server-Client

Client:

Server

Messages with different backends (email, sms, messaging app) can be sent from any frame (make frame from selection using SHOW link). Responses appear below the sent frame. and in an Inbox which contains links to all incoming messages, grouped by sender.

Publishing a frame exports it to html with title and css and markdown for LLMs.

other

Karpathys ideal blogging platform
file over app

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

discord
plausible analytics
atom/rss

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

markdeep
libh2o PowerDNS.org with nice articles

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/transmitting transformations to save space.

text with properties: x, y, font, width current font is in global state text(x,y width, height, text) places that text box scene: - Font - TextureAtlas - Cursor - Selection - textQuads - Shader (RenderQueue) html is hierarchy for search engines and relative positioning with css. llms like markdown, which is linear like html. LLMs still struggle with 3D understanding. assinging a style to a box is a meta op because it goes there and copies that style. default is always I just edit my style here. Editing the "original" is also meta op. Assign stlye like in browser debugger.
CTRL+CLICK to follow a link, else edit markdown for that link.

The process of language from far-reaching to linearized stories is analagous to the the process from abstract and ambiguous memory towards linear, factual history.
But history is told in language too. but there are ways to record direct experience of history. no such way to record thoughts? yet?
machines can probably translate brain signals into languages and back into experience.
In computers, all abstractions exist for efficiency, so there is very little given that I must build on.
it is less obvious what to build on in interaction with the mind? language? it is not the bottom: my experience exists in higher resolution and volume than what I can reproduce in language.
most experience quickly becomes irrelevant. Would arguably be rather burdensome if recorded. How to efficiently and accurately encode discoveries in the mind. thinking is a compression algorithm. Most attempts are shit, the remaining should be expressed in high quality to save others from doing the same.
problems are lack of introspection about why something appears meaningful or useful and lack of empathy for other people, the student, who does not understand the news.

it seems that the communication problem is solved.
no, the properties of the computer are still useful, like perfect memory, communication speed, processing autonomous processing. but the interface is so slow and tedious that it is not worth it to put most of my mind into it because I have to manage it too.
at some point it might interpret brain signals and aid them directly. an obvious problem here is that I don't understand most quotes and can not learn from them. I am not attracted to books because its hundreds of pages of nothing to use or remember. what to do with this?
the ideal publishing platform does not exist. there is no bottom up independent easy publishing app. there is obsidian but it can't contain worlds. Narrow and ugly under the hood?
build a simple editor that can just do markdown, sync with remote servers and be a file system? privacy map, history, messaging, email, ai integration. its like a platform with those features building on some simple blocks.

TARGET:

PATH:
simplify editor and ready the abstractions for html; implement html WYSIWYG; QoL editor: hyphenation, shortcuts, good pasting, images; file sytstem; history; server synchronization over https; https server