Open Source Project MistTracker

Good afternoon, I has been a while since my last post. Things have certainly changed since that time, but my ability to come up with crazy projects has not. So without further delay…

I was having a conversation with my sister about why movies and games suck, and we came to the conclusion that there isn’t enough consistency. Imagine how complex it is to coordinate several authors in a series like The Horus Heresy, no wonder. To solve this problem, created MistTracker .

It started out based on a custom CRM that I developed for a buddy, so early versions are meant to be deployed in a Google Workspace.

2 Likes

FAQ:

What is MistTracker?
MistTracker is a relational database with resources for ingest of source materials, like a narrative, maps, character models, ect. Additional information here.

What are the system requirements?
In short any system that can run a modern Linux distro with at least 8GB of RAM. Full System Requirements below.

What makes Mist different from other solutions:
The heavy focus on the simulation engine has provided an excellent foundation for nearly all functionality within the Mist environment. Nearly all functions are async from the foundation and can be run on either cpu or gpu for maximum resource utilization. This is the latest update of the rendering/interaction pipeline.

What security measures are in place?
MistMulti extends the functionality of MistTracker by allowing for networked collaboration with p2p protocols. A full feature description of these can be found here.

Does MistTracker allow multiple users on the same device?
Yes, but not collaboratively without MistMulti module. This is very useful for things like instancing for map zones, or sharing resources without sharing a workspace. You will need to figure out sharing the mouse though as that is the only way to interact with the GUI at this time.

Are you crazy?
Who can tell.

How is this different from tools such as Lumberyard or Godot?
Mist is a collaborative, secure, data-centric simulation and tracking platform, not a general-purpose game engine. It is designed for scientific, creative, or analytic workflows where data, provenance, and collaboration are as important as visualization—making it fundamentally different from engines like Lumberyard or Godot .

If you are interested in the up to date reference API for developers it can be found here.

Who is the intended audience for this platform?
In short, anyone who loves stories, ideas, or understanding. For more specific use cases check this post out.

What is the proof that this is your idea and you didn’t just steal it all from insertProjectNameHere?
Logical proof of work. Code Abstract if you would like to test an idea out quickly.

My humble request.

1 Like

Is this separate/different from plastic (git but for game developers)?

This is completely separate from Plastic. Had no idea what that was before today. I’ve been just been making stuff to be modular in this way because I have been doing updates based on an intended use case of the Core functionality at that time.

Code is all written by me so far, with inspirations from many things but no direct copies or anything like that. I just know what it is supposed to do and start from there. Examples would be the P2P service. Which is inspired on libTorrent-Main but does not have libTorrent-Main as a dependency.

1 Like

MistIllum

is now up on The Hub!

Features of this release are a complete physics engine and new rendering modes: 3D and ND with a mostly pure math for the theory. Also, there is scaffolding for interactions and such.

Plenty of work to be done still, but I haven’t made a commit all day and it is time for a break.

Mist is a collaborative, multi-user, 4-dimensional item tracking and simulation platform that combines advanced data organization, real-time physics, and secure peer-to-peer interaction. It is designed for users to explore, organize, and interact with complex data and objects in a spatial-temporal environment, supporting both individual and group workflows.


What is Mist?

Mist is a 4D definite item tracker and interactive simulation environment. It enables users to:

  • Organize and track items, categories, and events across time and other dimensions.
  • Collaborate in real time with other users in a shared, persistent environment.
  • Visualize and manipulate data and objects using 3D/4D physics and advanced rendering.
  • Securely synchronize, audit, and analyze all interactions and changes.

What does Mist do?

  • Tracks Items in 4D:
    Mist lets users create, categorize, and relate items along time, category, and item axes, supporting complex, multi-dimensional data structures.
  • Supports Real-Time Collaboration:
    Multiple users can join the same session, see each other’s actions, and interact with the shared environment.
  • Provides Advanced Visualization:
    Users can navigate and view data in 3D and higher dimensions, switch between projection and render modes, and interact with a physics-based simulation.
  • Ensures Security and Integrity:
    All actions are authenticated, signed, and rate-limited. Anomaly detection, event banning, and consensus mechanisms maintain data integrity and prevent abuse.
  • Exports and Audits Sessions:
    At session end, Mist can export a detailed log of user interactions, including a mapping to sound frequencies for further analysis or creative use.

How does Mist do it?

  • Data Model:
    Mist uses a MySQL database (via mysql2) to persistently store users, sessions, items, categories, and relationships. The data model supports hierarchical and orthogonal organization (time → category → item).
  • Session Management:
    Each user session is tracked with a secure token. Sessions record navigation paths, opened items, and all interactions.
  • Multi-User & P2P:
    MistMulti.js manages user presence, secure messaging, and real-time event broadcasting using cryptographic authentication and optional Reed-Solomon FEC for message reliability.
  • UI & Physics:
    MistIllum.js provides the user interface, menu system, and physics engine for 3D/4D navigation, rendering, and interaction.
  • Security:
    Features include session tokens, public/private key cryptography, rate limiting, anomaly detection, event banning, and encrypted state sync.
  • Export & Analysis:
    On session end, Mist exports a log of all interactions, mapping them (optionally) to sound frequencies using a provided CSV, enabling replay, audit, or creative transformation.

Summary Table

Aspect Description
Purpose 4D item tracker, collaborative simulation, secure data environment
Core Tasks Track, organize, and relate items; real-time collaboration; advanced UI/physics
Security Auth, encryption, rate limiting, anomaly detection, event banning
Export Session logs, sound mapping, audit trails
How Node.js, MySQL, multi-user P2P, physics engine, modular UI, secure protocols

In short:
Mist is a secure, collaborative, multi-dimensional item tracker and simulation platform that lets users organize, visualize, and interact with data and each other in real time, with robust security, audit, and export features.

This is the updated API description for Mist related modules:
x11LibreMigration.txt (10.4 KB)
Still working on several functions. I’ll probably be able to merge by the end of the week.

The Mist Solution is a modular, open-source software framework designed for multi-user, multi-dimensional data tracking, visualization, and simulation. It is particularly suited for scientific, educational, and collaborative environments where complex relationships, provenance, and real-time interaction are important.


What is the Mist Solution?

Mist is a suite of Node.js modules (including MistTrackerVulkan.js, MistIllum.js, MistMulti.js, and MistCore.js) that together provide:

  • 4D definite item tracking (time, category, item, and additional dimensions)

  • 3D/4D/nD physics simulation and visualization

  • Multi-user, real-time collaboration (P2P and database-backed)

  • Advanced provenance and moderation (event tracking, anomaly detection, and user management)

  • Flexible UI (X11-native, CLI, and potential for web or VR integration)

  • Integration with scientific data and story-driven content (e.g., parsing RTF stories, pulsar maps)


What does it do?

  • Tracks and organizes data along multiple axes (time, category, item, etc.) in a relational and geometric model.

  • Visualizes data in 3D, 4D, or higher dimensions, supporting both standard and wave-based rendering.

  • Simulates physics using customizable metric tensors and physics engines for both UI and world interactions.

  • Enables multi-user collaboration with real-time state sync, event broadcasting, and secure messaging.

  • Supports moderation and provenance by tracking all actions, enabling anomaly detection, and enforcing user bans or event horizon logic.

  • Allows extensibility for scientific, educational, or creative applications (e.g., mapping pulsar data, collaborative story annotation).


How does it do it?

  • Data Storage: Uses MySQL for all persistent data (no Google Drive/Sheets dependencies), with a clear schema for lines, categories, items, users, and events.

  • In-Memory Model: Maintains a live MistModel for fast access and manipulation during sessions.

  • Physics and Rendering: Employs modular physics engines (MistPhysicsEngine, MistPhysicsEngineND) and rendering logic, with support for nD geometry, wave functions, and advanced projections.

  • UI and Input: Provides X11-native and CLI interfaces, with support for keybinds, tiling, and multi-monitor setups.

  • Multi-User: Implements P2P networking, session tokens, event handlers, and state sync via MistMulti.js.

  • Moderation: Tracks anomalous events, bans users/interactions, and supports provenance for all actions.

  • Extensibility: Functions and classes are modular, allowing integration with external data (e.g., story files, scientific images) and custom logic.


Why does it do it this way?

  • Scalability: MySQL and modular Node.js code allow for large, multi-user deployments.

  • Transparency and Provenance: Every action is tracked, enabling scientific reproducibility and robust moderation.

  • Flexibility: The nD model and modular physics/rendering engines support a wide range of use cases, from education to research.

  • Collaboration: Real-time, multi-user support is built-in, with secure messaging and event handling.

  • Open Standards: Uses open protocols, open-source libraries, and is designed for integration with other scientific and educational tools.


Comparable Open Source Solutions

While Mist is unique in its combination of nD data tracking, physics simulation, and multi-user collaboration, some comparable open-source projects include:

  • JupyterLab (with extensions): For collaborative, multi-user scientific data analysis and visualization.
  • OpenSpace: For multi-dimensional, collaborative visualization of space science data.
  • OpenSim: For multi-user, 3D virtual environments (less focused on nD data tracking).
  • CERN ROOT: For nD scientific data analysis and visualization (not multi-user or collaborative by default).
  • OpenMCT: NASA’s open-source mission control framework for time-series and relational data visualization.

However, none of these combine all the features of Mist (nD tracking, physics, real-time multi-user, provenance, and moderation) in a single, extensible solution.


Summary:
Mist Solution is a flexible, extensible, and collaborative platform for tracking, visualizing, and simulating complex, multi-dimensional data with robust provenance and moderation, leveraging open standards and modern Node.js/MySQL architecture.

1 Like

FAQ 003:

What is the history of this project?

I know, I know most people are going to say I had AI write for me. That is anything but the case I assure you. This is my earliest work on this from this very forum.

In summary it was an idea I had while working on a data governance project. I asked for time to implement it, but you know how these things go in companies, so when my contract expired. I was let go.

Platforms and code may change but ideas do not.

My earliest programming experience was porting TI-83 games to the TI-82 in math class during High School. I was listening but I had things to do so I used to also take notes. Stuff like flash cards, cheat sheets for math tests ect. And I never ended up doing much with it except chatting with friends.

I have tried very hard to go to college over the years, but like in High School I had things to do and personal circumstances just got in the way. So I never really ended up finishing.

Joined the military because I needed a job and thought it would be fun. Got into Air Traffic Control, the job was fun, but while I think the military as important of a calling, was not for me. So moved on from the military. Wouldn’t you know it military record keeping is so trash that I missed the opportunity to apply at the FAA due to age limitations and at the time they hadn’t granted an age waiver in decades according to rumors.

Ended up working in FBO operations, for a while. It was neat. Did that for a while until lockdowns… Anyway I don’t need to talk about that. Then I thought, I should start a company to make products. Which I actually did. It was tedious sure, but worth it for the experience alone.

That didn’t end up working out because dealing with the dictators of the farmers market demanded that I use their insurance provider instead of the one I was already paying for. They couldn’t sort their shit out, so interacting with them was a nightmare. No one on the mailing list ever read anything in the thread before and none of them would look at the paperwork I provided to comply with their requirements.

After that I worked as a field technician for a service based mega corp. The software they provided was adequate for what they wanted us to do, but inflexible for the end user by design. Dealing with anyone in the coordination department was difficult because the company had just 2 people handling all scheduling for an entire region for a long while. I couldn’t provide the service to the customer that I thought that they deserved and customers often complained to me directly about this.

And now I am on my next adventure in life dealing with personal matters that make it difficult to get regular work, but fortunately those same limitations have provided me the time and opportunity to bring this idea to life.

Mist Illum has now entered alpha testing. This is a description of the current build. Several areas still need implementation, particularly the nD map overlay in engine and a lot of ease of use things.

Mist Illum 0010 Test Build.pdf (82.9 KB)

// --- Session and State Management (MistTrackerVulkan.js) ---
startSession           // Initialize a new user session, set up session variables and state (user, time, etc.)
endSession             // End the current session, persist state to database
onExit                 // Handle unexpected session termination (e.g., window close), persist state
priorState             // Load previous state from persistent storage (e.g., mySQL)
nextState              // Load next state from persistent storage (e.g., mySQL)
captureViewport        // Capture current viewport state and persist to database
persistUpdate          // Save current rendered items (not full user path) to persistent storage
userPath               // Save user navigation path for session tracking
MapModeState           // Class for 3D navigation state

// --- Data Model and CRUD Operations (MistTrackerVulkan.js) ---
createPrimaryLine      // Initialize the primary (time) line in the database
addCategoryLine        // Add a category line at a specific time index
addItemLine            // Add an item line for a category
loadPrimaryLine        // Load primary line (time indexes) from database
loadCategoriesForTime  // Load categories for a given time index from database
loadItemsForCategory   // Load items for a given category from database
addTimeIndex           // Add a new time index to the primary line
addCategory            // Add a new category for a given time index
addItem                // Add a new item for a given category
addCharacterLocation   // Add a character's location at a given time
getCharacterLocationsByTime // Get all character locations for a given time
getCharacterLocation   // Get a character's location at a specific time

// --- Data Integrity and Utilities (MistTrackerVulkan.js) ---
ensureMistDatabase     // Ensure the mySQL database and required tables exist
updateMistData         // Update database with latest data from external sources (e.g., story files)
ensureCharacterLocationsTable // Ensure the CharacterLocations table exists
loadMistUser           // Load user data from database
getMistDataTables      // Utility: Get references to required tables in the database
getMistTables          // Utility: Get references to main tables in the database
loadWordDefinition     // Load dictionary definition for a word from database

// --- Viewport and UI Logic (MistTrackerVulkan.js) ---
getMistViewportData    // Provide structured data for the UI (lines, categories, items)
advanceSelectionMode   // Advance selection mode state
getViewportCentering   // Compute viewport centering offsets
isItemVisible          // Check if an item is visible in the current session
handleSelectionBackend // Handle selection logic in memory
transformStream        // Handle user selections, update session state, and compute nD vectors for lines
saveSessionPath        // Save user navigation path to persistent storage
saveCurrentState       // Save current session state to persistent storage
calculateLineOrientation // Compute orientation of lines for nD arrangement (for GPU or CPU)
getSessionId           // Generate unique session identifier (user + timestamp)
initViewport           // Initialize the viewport with current state and user input
renderViewport         // Render the viewport using current state and visible items (for Vulkan/OpenGL)
selectTimeIndex        // Select a time index from the primary line
selectCategory         // Select a category from the categories for the selected time index
selectItem             // Select an item from the items for the selected category
showAddTimeInput       // Show input for adding a new time index
showAddCategoryInput   // Show input for adding a new category
showAddItemInput       // Show input for adding a new item
showInputBox           // Show generic input box for user input
handleSelection        // Handle user selection, update session state, and persist as needed
getLineTransformationMatrix // For Vulkan/OpenGL rendering

// --- Keybinds and Input (MistTrackerVulkan.js) ---
mapKeybinds            // Allow user to change keybinds via user input (X11 or fallback)
handleInput            // Handle key or mouse input event, dispatch to menu/environment
userKeybinds           // Current user keybinds mapping

// --- Advanced Rendering and Navigation (MistIllum.js, MistTrackerVulkan.js) ---
hourGlass              // Compute nD orthogonal vectors for line arrangement; project to 2D/3D for display
enableRelativeNavigation // Enable mouse or input-based navigation along any line, relative to parent/plane
cullVisible            // Only show items/lines opened by the user in the current session (use session.opened)
gramSchmidt            // Orthonormalize vectors for nD arrangement (for GPU or CPU)
projectItemsTo3D       // Project items and locations to 3D for map mode
getMapModeProjection   // Get 3D projection for map mode
storyWriter            // Parse and extract structured data from story files (RTF or plain text)
mapRead                // Requirements block for mapReader
mapReader              // Map reader for image-based location extraction

// --- Lighting, Rendering, and Physics (MistIllum.js, pureMathPhysicsEngine.js) ---
LightSource            // Class for all light sources (point, directional, ambient, etc.)
globalIllumination     // Wave-based global illumination using interference and metric tensors (see pureMathPhysicsEngine.js)
fastTransform          // Fourier transform for ray/wave analysis (DFT/FFT)
worldWarp              // Transform 3D projected volume to different geometries (plane, sphere, torus, etc.)
wireFrames             // Generate wireframe mesh for items using metric tensor
rastRenderMap          // Rasterize wireframes and combine with texture/wave-based shading
waveFunction           // Core wave function: psi = A * exp(i(kx - wt)), used for light/sound (see pureMathPhysicsEngine.js)
interferencePattern    // Calculate interference pattern for wave-based rendering and audio
applyInterference      // Apply interference pattern to objects (modulate intensity, color, etc.)

// --- Audio and Soundscape (MistIllum.js, pureMathPhysicsEngine.js) ---
audioQueue             // Queue a sound file for playback, modulated by wave/geometric logic
volumeGlobal           // Set global volume, optionally modulated by wave envelope
volumeAmbient          // Set ambient sound volume, modulated by spatial/temporal wave logic
volumeInteract         // Set volume for object interaction sounds, modulated by proximity/interference
volumeDialogue         // Set volume for character dialogue, modulated by distance and wave envelope

// --- Settings and UI (MistIllum.js) ---
settingsMenu           // Display and manage the settings menu, including audio/wave/geometric parameters
mistFirstStart         // Display title, credits, and disclaimers for Mist modules
mistSetup              // Setup/check dependencies for MistTracker, MistMulti, MistIllum
mistDepend             // Check user system for software/hardware dependencies
mistWarn               // Display a warning message to the user
warnTypes              // Enum/class for warning types
mistMenu               // Display a menu overlay for the Mist solution

// --- Menu and Environment Interaction (MistIllum.js) ---
MistMenuControl        // Menu control logic using viewport functions and 3D/nD mode switching
handleUserInput        // Route input to menu or environment logic
handleMenuInput        // Handle input for menu objects
handleEnvironmentInput // Handle input for environment (scene/world) objects

// --- Multi-User, P2P, and Real-Time Collaboration (MistMulti.js) ---
addUserSession         // Add or update a user session in memory
removeUserSession      // Remove a user session from memory
updateUserPresence     // Update user's lastSeen and state in memory
announceHostSession    // Announce host's public key/session info to DHT
discoverHostSession    // Discover host's session by searching DHT
generateSessionToken   // Generate a secure random session token
signMessage            // Sign a message using user's private key
verifyMessage          // Verify a message signature using sender's public key
onEvent                // Register an event handler for a specific event type
emitEvent              // Emit an event to all handlers and broadcast to peers
broadcastToPeers       // Use P2P transport to send messages to all connected peers
syncStateWithPeer      // Send local state to peer, receive remote state, and merge
encryptMessage         // Encrypt message using recipient's public key (ECC/AES)
decryptMessage         // Decrypt message using own private key (ECC/AES) *WIP*
canSendMessage         // Rate limiting for outgoing messages per user
mergeState             // Merge local and remote session state, resolving conflicts

// --- Physics Engine and Metric Tensor (MistIllum.js, pureMathPhysicsEngine.js) ---
MistPhysicsEngine      // Physics engine using metric tensor for all spatial logic (see pureMathPhysicsEngine.js)
MetricTensor           // General nD metric tensor for distance, projection, transformation
MetricTensor3D         // 3D-only metric tensor for spatial calculations
dimensionalStack       // Stack objects/spaces in higher dimensions *WIP*
perspectiveTransform   // Calculate apparent distance/size from different dimensional perspectives *WIP*
projectToLowerDimension// Project higher-dimensional object into lower dimension over time/motion *WIP*
decomposeHigherToLower // Decompose higher-dimensional object into lower-dimensional "shadows" *WIP*
extraDimensionMode     // Treat extra dimensions as spatial axes or object properties *WIP*
setDimensionLimit      // Set limits/boundaries for extra dimensions *WIP*
energyDistribution     // Simulate energy distribution across extra dimensions
applyCurvature         // Apply curvature/non-flat geometry to extra dimensions *WIP*

// --- Advanced Physics and Math (pureMathPhysicsEngine.js) ---
eulerLagrange          // Euler-Lagrange equation for wave function (see pureMathPhysicsEngine.js) *WIP*
gaussLawMagnetism      // Gauss's law for magnetism
principleOfStationaryAction // Principle of stationary action
pilotWave              // Pilot wave theory for defined objects
bellTheorem            // Bell's theorem culling logic
locality               // Check if two points are local to each other
lightWave              // Relationship between light wave and arrival at objects
relativeAcceleration   // Relative acceleration between two velocities over time

// --- Moderation and Security (MistMulti.js) ---
cullObject             // Remove object from scene/model, call deleteUser if user (see Bell's theorem and event horizon logic)
deleteUser             // Remove user from active sessions and/or database
rateLimitWarn          // Warn user if rate limit is exceeded (from MistMulti.md)

// --- Swarm Health and Data Coherence (MistTrackerVulkan.js, MistMulti.js, pureMathPhysicsEngine.js) ---
checkAndSyncEvent      // Check event probability, sync to swarm, require confirms for anomalies, ban if needed
AnomalousResults       // Table of anomalous results for error checking and moderation
isInteractionBanned    // Check if an interaction is banned for a user
eventHorizonUser       // Ban user and flush all Mist data from host
flushUserData          // Remove all user data from persistent tables
banInteraction         // Ban a specific interaction type or event

// --- Milestone Modeling (MistTrackerVulkan.js, MistIllum.js) ---
Milestone              // Milestone class for precision and mode enablement (see Mist V00089.md)
MilestoneManager       // Manages milestones, tensor metric tables, and mode unlocks
milestoneManager       // Singleton instance for milestone tracking
getAvailableModes      // Returns available projection/render modes based on milestones
showModeSelectionMenu  // UI for selecting modes, only if milestones are met
trySwitchMode          // Attempt to switch mode, only if milestone is achieved

// --- User Profile Management (MistTrackerVulkan.js) ---
nominateSuccessor              // Nominate a successor by email (before 6th milestone)
nominateSuccessorPGP           // Nominate a successor by PGP cert (after 6th milestone)
nominateSuccessorFlexible      // Nominate successor, enforcing milestone-based method

// --- Miscellaneous and Utility (MistIllum.js, MistMulti.js, MistTrackerVulkan.js) ---
createVoxelObject       // Create a voxel-based 3D object
updateDistanceFromObserver // Update object's distance from observer
computeAngularMomentumMap // Compute angular momentum map for object
isEdgeVoxel            // Determine if a voxel is on the edge of an object
interactObjects        // Cause interaction between objects using tensors
spawnObjectNearPlayer  // Spawn a new object near the player
distributeEnergy       // Distribute energy across dimensions
deformObject           // Apply deformation to object based on energy distribution
composeWaves           // Compose multiple wave objects
intensityHardnessRelationship // Relationship between intensity and object hardness
particleWaveDuality    // Model particle-wave duality

// --- Multi-User Moderation and Provenance (MistMulti.js) ---
createProvenance       // Attach provenance to user actions/events
grimReaper             // Track database tensor inputs for moderation

// --- Functions returning null (Work In Progress) ---
projectToLowerDimension// *WIP* Returns null
decomposeHigherToLower // *WIP* Returns null
extraDimensionMode     // *WIP* Returns null
setDimensionLimit      // *WIP* Returns null
perspectiveTransform   // *WIP* Returns null
dimensionalStack       // *WIP* Returns null
applyCurvature         // *WIP* Returns null
eulerLagrange          // *WIP* Returns null
decryptMessage         // *WIP* Returns null

// --- Migration Notes ---
// - Replace all Google Sheets/Drive operations with mySQL queries and file I/O.
// - Replace HTML Service UI with x11 or other native UI toolkit.
// - Use Vulkan/OpenCL for vector math, rendering, and possibly data processing.
// - All session and state persistence should use mySQL or equivalent.
// - All vector and matrix operations should be GPU-accelerated where possible.
// - All wave, metric, and physics logic should reference pureMathPhysicsEngine.js for consistency.
// - All multi-user and moderation logic should follow MistMulti.md guidelines.
// - Milestone-based mode enablement should be enforced for all advanced features.
// - Provenance should be attached to all user actions and events.

FAQ 004:

What is the goal of the MistTracker/MistIllum project?

  1. To use assets that you have made like 3d models, pictures, or story scripts onto one big story board essentially. Suppose you have been working on a character backstory for a ttrpg, you can import that into the database. Once an item has been put into the database it will compose a rough story line based on the backstory. It order all events in relationship to time based on how you wrote the backstory. It can derive relationships based on context in the story. Once that is done, it will present the user with a 3d environment of those events as steps in time. So it can play out your script for you or for whomever else is using the same project, because storytelling should be a collaborative project.

  2. You can define any sort of system you want within your story world. Mist Illum, is my game idea that uses physics as close to irl as possible to research new interactions for the underlying MistTracker system.

  3. Mist Tracker can be used for integrations with an AI if you want or whatever you really want. I’m also planning to port Mist Tracker to TempleOS to run with an AI for more interesting research opportunities. Only slightly joking on this one.

FAQ 005:

You’ve described importing assets into the database, and how you can import all kinds of assets, like backstories (assuming text format for this), 3d models and such?

Is there a system which tries to interpret the text? Do you need to manually input it into the timeline once the file is imported? Is there a syntax for how things need to be in the file for the timeline to be accurate?

  1. Yes, there is a system to do the interpretation, for you. You are essentially setting the stage with your story. It is semi autonomous because I need more writing samples from volunteers to make a more complete interpretation layer. At the moment, it will ingest any rtf named “story.rtf” in the parent directory. It also screens for hidden junk and quarantines it for research purposes. The timeline is generated based on the story you provide. Models are not implemented at the moment because I only just finished the physics engine among other things. There is an input for pictures, at the moment it just sorts by pixel and obviously needs more work. The only important part for modeling would be using consistent scaling for each model. I will probably be trying to 3d models from Blender at first, but maybe there is a better way for that. I haven’t really thought about it much yet. Mist Illum is essentially doing this whole thing backwards because of how I’m planning to do the graphics. It is… quite unique.

  2. My plan is to start with an empty universe and see how things progress actually, which is why I’ve included so many collaborative features and implemented swarming. Sometimes it may take a moment or two to perform a certain interaction because it hasn’t been performed in the, for lack of a better term, “universe” hasn’t occurred across any session tracked by the swarm. So if it is a simple interaction, you won’t need any error checking, but when things get more complex and relativity gets involved, more error checking is required so, you may get to try it once. It gets submitted to the swarm for approval.

Updates for 7D representations of objects based on this idea: 3D Time

I have also implemented a custom MySQL wrapper to keep user setup requirements to a minimum and because I’m too lazy to fix NPM on my system.

Mist 7D Update

#### **1\. Database Layer**

* **Update all references to MySQL:**  
  * The solution now uses a custom MistMySQL.js wrapper (inspired by mysql-master) with queryAsync, connectAsync, and endAsync methods.  
  * All CRUD and session persistence functions should use this interface.  
* **Time Vector Support:**  
  * All time-based data (e.g., CharacterLocation, session state) now uses a 3-element time vector `[T0, T1, T2]` (quantum, interaction, cosmological) instead of a single time value.  
  * Database schema and queries must support t0, t1, t2 columns.

#### **2\. Session and State Management**

* **Session objects** now include a timeVec property.  
* **Session persistence** (endSession, saveSessionPath, etc.) should serialize the full session object, including timeVec.  
* **On exit** and signal handling should ensure session state is saved using the new DB interface.

#### **3\. Data Model and CRUD**

* **CRUD functions** (e.g., addCharacterLocation, getCharacterLocationsByTime) now require and use the time vector.  
* **Migration scripts** may be needed to convert legacy single-time data to the new vector format.

#### **4\. UI and Viewport**

* **Selection and navigation** logic (e.g., SelectionModeState) now tracks three time indices.  
* **Projection and rendering** functions (e.g., projectItemsTo3D) use the timeToSpace mapping from MistIllum.js to convert time vectors to spatial coordinates.  
* **Menu and settings** overlays are implemented in MistIllum.js and support both CLI and X11 UI renderers.

#### **5\. Physics and Math**

* **Metric tensors** are now 7D (metricTensor7D) to support three time dimensions and four spatial/energy axes.  
* **All physics, wave, and rendering logic** (e.g., waveFunction, quantumMassEvolution, gravWaveDeltaV) use the appropriate time dimension as per the new model.  
* **Landscape/environment generation** uses generateLandscapeFromTime to create 3D environments as a product of the three time dimensions.

#### **6\. Multi-User and P2P**

* **Session and event management** uses in-memory maps and message queues.  
* **Peer-to-peer messaging** and event handling are implemented using stubs or minimal logic, with placeholders for cryptography and DHT.  
* **Rate limiting** and provenance tracking are enforced as per MistMulti.js.

#### **7\. Moderation and Swarm Health**

* **Anomaly detection** and event horizon logic are implemented, with in-memory and persistent tracking of anomalous events and banned users/interactions.

#### **8\. Milestone and Mode Management**

* **MilestoneManager** enables/disables projection and render modes based on achieved milestones.  
* **Mode selection menus** are milestone-aware and only show available modes.

#### **9\. Migration and Compatibility**

* **All Google Sheets/Drive operations** are replaced with MySQL queries and file I/O.  
* **All HTML Service UI** is replaced with X11 or CLI UI.  
* **All vector/matrix operations** are ready for GPU acceleration (Vulkan/OpenCL), but currently implemented in JS.

#### **10\. Testing and Stubbing**

* **All external dependencies** (npm modules, system calls) are stubbed or replaced for environments where npm is not available.  
* **Testing** should focus on pure JS logic, with stubs for DB, crypto, and system calls.


Mist Security Feature Update 2

MistTracker incorporate several security features, primarily in its multi-user and P2P modules, to ensure user authentication, message integrity, confidentiality, and abuse prevention. Here’s a summary of the key security features and their purposes:


1. Session Tokens

  • Where: MistMulti.js
  • What: Each user session is assigned a cryptographically secure session token (generateSessionToken).
  • Why: Prevents session hijacking and uniquely identifies users in the P2P network.

2. Public/Private Key Cryptography

  • Where: MistMulti.js (ECC via elliptic and Node.js crypto)
  • What:
    • Signing: Messages can be signed with a user’s private key (signMessage) and verified with the public key (verifyMessage).
    • Encryption: Messages can be encrypted using ECC-derived shared secrets and AES (encryptMessage/decryptMessage).
  • Why:
    • Authentication: Ensures that only the legitimate user can sign messages.
    • Integrity: Detects tampering with messages.
    • Confidentiality: Protects sensitive data in transit between peers.

3. Rate Limiting

  • Where: MistMulti.js
  • What:
    • Each user’s message sending rate is limited (e.g., 50kbps per user via canSendMessage).
  • Why:
    • Abuse Prevention: Mitigates spam, flooding, and denial-of-service attacks from malicious or buggy clients.

4. Event and Interaction Banning

  • Where: MistTrackerVulkan.js
  • What:
    • Interactions/events can be banned (banInteraction), and users can be “event-horizoned” (banned and flushed from the system) if they violate rules or trigger anomalous behavior.
  • Why:
    • Integrity: Maintains the health and trustworthiness of the collaborative environment.
    • Abuse Prevention: Quickly isolates and removes malicious or disruptive users.

5. Anomaly Detection and Swarm Confirmation

  • Where: MistTrackerVulkan.js
  • What:
    • Events with statistically anomalous properties are flagged and require confirmation from multiple peers before being accepted (checkAndSyncEvent, onEvent(‘anomalyCheck’)).
  • Why:
    • Consensus and Trust: Prevents a single user from introducing corrupt or improbable data without peer review.

6. Forward Error Correction (FEC) for Message Reliability

  • Where: MistMulti.js
  • What:
    • Reed-Solomon FEC is used to encode messages, allowing recovery from packet loss or tampering (encodeMessageFEC, decodeMessageFEC).
  • Why:
    • Reliability: Ensures messages are delivered intact even in unreliable network conditions.

7. User Data Flushing and Provenance

  • Where: MistTrackerVulkan.js
  • What:
    • When a user is banned, all their data is flushed from the system (flushUserData).
    • All events/actions are tagged with provenance metadata (who, when, session, etc.).
  • Why:
    • Accountability: Enables tracing and auditing of actions.
    • Privacy: Ensures that banned users’ data does not persist.

8. Encrypted State Sync and Peer Discovery

  • Where: MistMulti.js
  • What:
    • State synchronization and peer discovery can be encrypted and authenticated.
  • Why:
    • Confidentiality and Integrity: Protects session state and peer information from eavesdropping or tampering.

Summary Table

Feature Purpose
Session tokens Unique, secure user identification
Public/private key crypto Authentication, integrity, confidentiality
Rate limiting Prevent spam and DoS
Event/user banning Remove abusers, maintain system health
Anomaly detection/confirmation Peer consensus, prevent data corruption
Reed-Solomon FEC Reliable message delivery
Data flushing/provenance Accountability, privacy, audit trail
Encrypted state sync/discovery Secure P2P communication

In summary:
The Mist solution uses cryptographic authentication, message signing/encryption, rate limiting, anomaly detection, event banning, and FEC to provide a secure, reliable, and abuse-resistant collaborative environment. These features protect user data, ensure message integrity, and maintain the trustworthiness of the multi-user system.

Minimum System Requirements

Operating System

  • Linux (preferred for X11, wmctrl, pactl, and native multi-monitor support)
  • Windows or macOS (possible, but some features may require adaptation or emulation)

Hardware

  • CPU: Dual-core 2 GHz or better
  • RAM: 4 GB minimum (8 GB recommended for multi-user or large datasets)
  • Storage: 500 MB free disk space (more for large datasets or logs)
  • Display: 1920x1080 or higher recommended for multi-monitor/tiling features
  • GPU: Required for advanced 3D/4D rendering (Vulkan/OpenGL compatible GPU recommended)

Software Dependencies

  • Node.js (v14 or newer recommended)
  • npm (for installing dependencies)
  • MySQL Server (v5.7 or newer, v8+ recommended)
  • mysql2 Node.js package (npm install mysql2)
  • csv-parse Node.js package (npm install csv-parse)
  • elliptic Node.js package (npm install elliptic)
  • reed-solomon Node.js package (npm install reed-solomon)
  • uuid Node.js package (npm install uuid)
  • canvas Node.js package (npm install canvas) (for map/image parsing)
  • wmctrl (Linux, for window management/tiling)
  • pactl (Linux, for audio volume control)
  • xclip or clipboardy (for clipboard support in GUI/X11)
  • libpng, libjpeg, build-essential (for native modules like canvas)

Network

  • Local network or internet access for multi-user/P2P features
  • Open ports as required for P2P communication (configurable)

Recommended System Requirements

  • OS: Ubuntu 20.04+ or recent Fedora/Debian (for best compatibility with X11 tools)
  • CPU: Quad-core 2.5 GHz+
  • RAM: 8 GB+
  • GPU: Dedicated GPU with Vulkan/OpenGL 4.x support (NVIDIA/AMD/Intel)
  • MySQL: v8+ with mysql_native_password authentication enabled
  • Node.js: v18+ (for latest JS features and performance)
  • Audio: ALSA or PulseAudio configured for sound output

Additional Notes

  • Windows/macOS:
    • Some features (tiling, X11, wmctrl, pactl) may not work natively. Use WSL2 (Windows Subsystem for Linux) or adapt scripts for your OS.
  • Database:
    • Ensure MySQL user authentication is compatible (mysql_native_password).
  • Multi-user/P2P:
    • Firewall and NAT configuration may be required for peer discovery and direct connections.
  • Optional:
    • For advanced physics or rendering, a CUDA/OpenCL-capable GPU may improve performance.

Summary Table

Component Requirement/Recommendation
OS Linux (preferred), Windows/macOS possible
Node.js v14+ (v18+ recommended)
MySQL v5.7+ (v8+ recommended)
RAM 4 GB (8 GB+ recommended)
CPU Dual-core 2 GHz+ (Quad-core recommended)
GPU Vulkan/OpenGL compatible
Packages mysql2, csv-parse, elliptic, reed-solomon, uuid, canvas, etc.
Tools (Linux) wmctrl, pactl, xclip
Network LAN/internet, open ports for P2P

In summary:
A modern Linux system with Node.js, MySQL, required npm packages, and X11 utilities will provide the best experience. Windows/macOS are possible with some adaptation. A dedicated GPU is recommended for advanced rendering.

1 Like

Mist Solution API Documentation

Core Modules Overview

Each function is annotated with its source module and primary purpose. Functions are grouped by module and functionality.


## MistIllum.js (Visualization and Metric Tensors)
class MetricTensorND {
    constructor(rank: number, data: number[][])
    intervalSquared(p1: vec[], p2: vec[]): number  // Calculate squared interval
    project(vec: vec[], targetRank: number): vec[] // Project to lower dimension
    transform(vec: vec[]): vec[]                   // Apply metric transformation
}

### Asset Management
```typescript
createShaderModule(device: VkDevice, assetId: string, db: Connection): Promise<VkShaderModule>
loadAsset(assetId: string, db: Connection): Promise<Asset>
ensureAssetsTables(db: Connection): Promise<void>
generateAssetId(): string

### Security and Moderation
```typescript
cullObject(obj: Object): void               // Remove object from scene/model
deleteUser(userId: string): void            // Remove user and cleanup
rateLimitWarn(userId: string): void         // Rate limit warningPhysics Core)

### Physics Engine
```typescript
class MistPhysicsEngineND {
    // Core nD physics engine with quantum mechanics support
    constructor(config: { mode: string, metric: MetricTensorND })
    setMode(mode: string): void              // Set physics engine mode (3D/4D/nD)
    distance(p1: vec[], p2: vec[]): number   // Calculate distance using appropriate metric
    gravityAt(p: vec[], mass?: number): number // Calculate gravity at point
    bellTheorem(a,b,c,d: number): boolean    // Bell's theorem validation
    pilotWave(psi: number, potential: number): number // Pilot wave calculations
    locality(p1: vec[], p2: vec[]): boolean  // Check spatial locality
    lightWave(source: vec[], obj1: vec[], obj2: vec[]): {time1: number, time2: number}
    eulerLagrange(L: Function, q: vec[], qDot: vec[]): vec[] // Euler-Lagrange equations
    particleWaveDuality(particle: Object, wave: Object): Object // Particle-wave modeling
}
endSession             // End current session, persist state to database, cleanup resources
onExit                // Handle unexpected termination, save state, trigger user presence update
captureViewport        // Capture viewport state and persist to database with timestamps
saveSessionPath       // Save user navigation path with provenance metadata
saveCurrentState      // Save current UI and rendering state for session persistence
MapModeState          // Class for 3D/nD navigation state, with metric tensor support
SelectionModeState    // Tracks selection steps (time/category/item) with input handling
Milestone             // Class for tracking precision and mode enablement progression
MilestoneManager      // Manages milestone-based feature unlocks and tensor metricsion and State Management (MistTrackerVulkan.js) ---
startSession           // Initialize a new user session, set up session variables and state (user, time, etc.)
endSession             // End the current session, persist state to database
onExit                 // Handle unexpected session termination (e.g., window close), persist state
priorState             // Load previous state from persistent storage (e.g., mySQL)
nextState              // Load next state from persistent storage (e.g., mySQL)
captureViewport        // Capture current viewport state and persist to database
persistUpdate          // Save current rendered items (not full user path) to persistent storage
userPath               // Save user navigation path for session tracking
MapModeState           // Class for 3D navigation state
SelectionModeState     // Tracks selection step and indices for time/category/item

// --- Data Model and CRUD Operations (MistTrackerVulkan.js) ---
createPrimaryLine      // Initialize the primary (time) line in the database
addCategoryLine        // Add a category line at a specific time index
addItemLine            // Add an item line for a category
loadPrimaryLine        // Load primary line (time indexes) from database, generate if missing
loadCategoriesForTime  // Load categories for a given time index from database, generate if missing
loadItemsForCategory   // Load items for a given category from database
addTimeIndex           // Add a new time index to the primary line
addCategory            // Add a new category for a given time index
addItem                // Add a new item for a given category
addCharacterLocation   // Add a character's location at a specific time
getCharacterLocationsByTime // Get all character locations for a given time
getCharacterLocation   // Get a character's location at a specific time
resetMistModel         // Reset the in-memory MistModel to its initial state
addUserToMistModel     // Add a user to MistModel
findUserInMistModel    // Find a user in MistModel by accountId

// --- Data Integrity and Utilities (MistTrackerVulkan.js, MistMulti.js) ---
ensureMistDatabase     // Create/verify MySQL schemas and tables with proper constraints
updateMistData         // Update from local files (replaces Google Drive integration)
ensureCharacterLocationsTable // Create/verify character location tracking table
loadMistUser           // Load/create user with proper account management
getMistDataSheets      // Get data schema table references with proper access checks
getMistSheets          // Get main schema table references with security context
getMistDataTables      // Get required table references with integrity validation
getMistTables          // Get core table references with transaction support
loadWordDefinition     // Load and validate word definitions with metadata
flushUserData          // Remove user data with proper cascading/cleanup
banInteraction         // Ban interaction with swarm notification
checkAndSyncEvent      // Validate events with peer consensus
grimReaper            // Monitor tensor inputs for anomalies
createProvenance      // Attach metadata to all user actions
eventHorizonUser       // Ban user and flush all Mist data from host
isInteractionBanned    // Check if an interaction is banned for a user
hashInteraction        // Hash an event for moderation
createProvenance       // Attach provenance to user actions/events

// --- Viewport and UI Logic (MistCore.js, MistIllum.js) ---
getMistViewportData    // Provide structured data for the UI (lines, categories, items)
advanceSelectionMode   // Advance selection mode state based on user input
getViewportCentering   // Compute viewport centering offsets for UI
isItemVisible          // Check if an item is visible in the current session
handleSelectionBackend // Handle selection logic in memory, update session state
initViewport           // Initialize the viewport with current state and user input
renderViewport         // Render the viewport using current state and visible items
selectTimeIndex        // Select a time index from the primary line
selectCategory         // Select a category from the categories for the selected time index
selectItem             // Select an item from the items for the selected category
showAddTimeInput       // Show input for adding a new time index
showAddCategoryInput   // Show input for adding a new category
showAddItemInput       // Show input for adding a new item
showInputBox           // Show generic input box for user input
handleSelection        // Handle user selection, update session state, and persist as needed
calculateLineOrientation // Compute orientation of lines for nD arrangement
getLineTransformationMatrix // For Vulkan/OpenGL rendering
projectItemsTo3D       // Map items and locations to 3D for map mode
getMapModeProjection   // Get 3D projection for map mode

// --- Audio and Input Management (MistIllum.js, MistTrackerVulkan.js) ---
audioQueue             // Queue sounds with wave/geometric modulation
volumeGlobal          // Set master volume with wave modulation
volumeAmbient         // Set ambient audio with spatial/temporal waves
volumeInteract        // Set interaction volume with interference patterns
volumeDialogue        // Set dialogue volume with distance/envelope
mapKeybinds           // Configure X11 input bindings
handleInput           // Process X11 events with dispatch
getUserKeybind         // Get the current keybind for an action
setUserKeybind         // Set a keybind for a specific action
resetUserKeybinds      // Reset all user keybinds to default
userKeybinds           // Current user keybinds mapping

// --- Advanced Rendering and Navigation (MistIllum.js, MistTrackerVulkan.js) ---
hourGlass              // Compute nD orthogonal vectors for line arrangement
enableRelativeNavigation // Enable input-based navigation along any line, relative to parent/plane
cullVisible            // Only show items/lines opened by the user in the current session
gramSchmidt            // Orthonormalize vectors for nD arrangement
projectItemsTo3D       // Project items and locations to 3D for map mode
getMapModeProjection   // Get 3D projection for map mode
storyWriter            // Parse and extract structured data from story files (RTF or plain text)
mapRead                // Requirements block for mapReader
mapReader              // Map reader for image-based location extraction

// --- Lighting, Rendering, and Physics (MistIllum.js) ---
LightSource            // Class for all light sources (point, directional, ambient, etc.)
globalIllumination     // Wave-based global illumination using interference and metric tensors
fastTransform          // Fourier transform for ray/wave analysis (DFT/FFT)
worldWarp              // Transform 3D projected volume to different geometries (plane, sphere, torus, etc.)
wireFrames             // Generate wireframe mesh for items using metric tensor
rastRenderMap          // Rasterize wireframes and combine with texture/wave-based shading
waveFunction           // Core wave function: psi = A * exp(i(kx - wt)), used for light/sound
interferencePattern    // Calculate interference pattern for wave-based rendering and audio
applyInterference      // Apply interference pattern to objects (modulate intensity, color, etc.)
createVoxelObject      // Create a voxel-based 3D object
updateDistanceFromObserver // Update object's distance from observer
computeAngularMomentumMap // Compute angular momentum map for object
isEdgeVoxel            // Determine if a voxel is on the edge of an object
interactObjects        // Cause interaction between objects using tensors
spawnObjectNearPlayer  // Spawn a new object near the player

// --- Audio and Soundscape (MistIllum.js) ---
audioQueue             // Queue a sound file for playback, modulated by wave/geometric logic
volumeGlobal           // Set global volume, optionally modulated by wave envelope
volumeAmbient          // Set ambient sound volume, modulated by spatial/temporal wave logic
volumeInteract         // Set volume for object interaction sounds, modulated by proximity/interference
volumeDialogue         // Set volume for character dialogue, modulated by distance and wave envelope

// --- Settings and UI (MistIllum.js) ---
settingsMenu           // Display and manage the settings menu, including audio/wave/geometric parameters
mistFirstStart         // Display title, credits, and disclaimers for Mist modules
mistSetup              // Setup/check dependencies for MistTracker, MistMulti, and MistIllum
mistDepend             // Check user system for software/hardware dependencies
mistWarn               // Display a warning message to the user
warnTypes              // Enum/class for warning types
mistMenu               // Display a menu overlay for the Mist solution

// --- Menu and Environment Interaction (MistIllum.js) ---
MistMenuControl        // Menu control logic using viewport functions and 3D/nD mode switching
handleUserInput        // Route input to menu or environment logic
handleMenuInput        // Handle input for menu objects
handleEnvironmentInput // Handle input for environment (scene/world) objects
getAvailableModes      // Returns available projection/render modes based on milestones
showModeSelectionMenu  // UI for selecting modes, only if milestones are met
trySwitchMode          // Attempt to switch mode, only if milestone is achieved
trySwitchModes         // Alternate signature for mode switching
getMenuOptionsWithMilestones // Get menu options for all milestone-enabled modes

// --- Multi-User, P2P, and Real-Time Collaboration (MistMulti.js) ---
addUserSession         // Add or update a user session in memory
removeUserSession      // Remove a user session from memory
updateUserPresence     // Update user's lastSeen and state in memory
announceHostSession    // Announce host's public key/session info to DHT
discoverHostSession    // Discover host's session by searching DHT
generateSessionToken   // Generate a secure random session token
signMessage            // Sign a message using user's private key
verifyMessage          // Verify a message signature using sender's public key
onEvent                // Register an event handler for a specific event type
emitEvent              // Emit an event to all handlers and broadcast to peers
broadcastToPeers       // Use P2P transport to send messages to all connected peers
syncStateWithPeer      // Send local state to peer, receive remote state, and merge
encryptMessage         // Encrypt message using recipient's public key (ECC/AES)
decryptMessage         // Decrypt message using own private key (ECC/AES) *WIP*
canSendMessage         // Rate limiting for outgoing messages per user
mergeState             // Merge local and remote session state, resolving conflicts
encodeMessageFEC       // Encode message with Reed-Solomon FEC for reliability
decodeMessageFEC       // Decode message with Reed-Solomon FEC
sendReliableMessageToPeers // Send message shards to peers using FEC
onFECShardMessage      // Handle incoming FEC_SHARD messages and reconstruct original message
grimReaper             // Track database tensor inputs for moderation

// --- Physics Engine and Metric Tensor (MistIllum.js) ---
MistPhysicsEngine      // Physics engine for menu/navigation logic
MistPhysicsEngineND    // Physics engine for 3D/4D/nD world interactions and simulation
MetricTensor           // General nD metric tensor for distance, projection, transformation
MetricTensor3D         // 3D-only metric tensor for spatial calculations
MetricTensorND         // nD metric tensor for advanced physics

// --- Dimensional and Extra-Dimensional Utilities (MistIllum.js) ---
dimensionalStack       // Stack objects/spaces in higher dimensions
perspectiveTransform   // Calculate apparent distance/size from different dimensional perspectives
projectToLowerDimension// Project higher-dimensional object into lower dimension over time/motion
decomposeHigherToLower // Decompose higher-dimensional object into lower-dimensional "shadows"
extraDimensionMode     // Treat extra dimensions as spatial axes or object properties
setDimensionLimit      // Set limits/boundaries for extra dimensions
energyDistribution     // Simulate energy distribution across extra dimensions
distributeEnergy       // Distribute energy across dimensions
deformObject           // Apply deformation to object based on energy distribution
applyCurvature         // Apply curvature/non-flat geometry to extra dimensions
schwarzschildCurvature // Schwarzschild curvature for 4D spacetime
sphericalCurvature     // Spherical curvature for extra dimensions

// --- Advanced Physics and Math (pureMathPhysicsEngine.js, MistIllum.js) ---
eulerLagrange          // Euler-Lagrange equation for wave function
gaussLawMagnetism      // Gauss's law for magnetism
principleOfStationaryAction // Principle of stationary action
pilotWave              // Pilot wave theory for defined objects
bellTheorem            // Bell's theorem culling logic
locality               // Check if two points are local to each other
lightWave              // Relationship between light wave and arrival at objects
relativeAcceleration   // Relative acceleration between two velocities over time
composeWaves           // Compose multiple wave objects
intensityHardnessRelationship // Relationship between intensity and object hardness
particleWaveDuality    // Model particle-wave duality

// --- Moderation and Security (MistMulti.js, MistTrackerVulkan.js) ---
cullObject             // Remove object from scene/model, call deleteUser if user
deleteUser             // Remove user from active sessions and/or database, or warn/add strike
rateLimitWarn          // Warn user if rate limit is exceeded

// --- Swarm Health and Data Coherence (MistTrackerVulkan.js, MistMulti.js) ---
checkAndSyncEvent      // Check event probability, sync to swarm, require confirms for anomalies, ban if needed
AnomalousResults       // Table of anomalous results for error checking and moderation
isInteractionBanned    // Check if an interaction is banned for a user
eventHorizonUser       // Ban user and flush all Mist data from host
flushUserData          // Remove all user data from persistent tables
banInteraction         // Ban a specific interaction type or event

// --- Milestone Modeling (MistTrackerVulkan.js, MistIllum.js) ---
Milestone              // Milestone class for precision and mode enablement
MilestoneManager       // Manages milestones, tensor metric tables, and mode unlocks
milestoneManager       // Singleton instance for milestone tracking
getCurrentMilestoneOrder // Get the highest achieved milestone order
enableModeIfMilestone  // Enable a projection or render mode if milestone is achieved
listEnabledModes       // List all enabled projection and render modes

// --- User Profile Management (MistTrackerVulkan.js) ---
nominateSuccessor              // Nominate a successor by email (before 6th milestone)
nominateSuccessorPGP           // Nominate a successor by PGP cert (after 6th milestone)
nominateSuccessorFlexible      // Nominate successor, enforcing milestone-based method

// --- Miscellaneous and Utility (MistIllum.js, MistMulti.js, MistTrackerVulkan.js) ---
createVoxelObject       // Create a voxel-based 3D object
updateDistanceFromObserver // Update object's distance from observer
computeAngularMomentumMap // Compute angular momentum map for object
isEdgeVoxel            // Determine if a voxel is on the edge of an object
interactObjects        // Cause interaction between objects using tensors
spawnObjectNearPlayer  // Spawn a new object near the player

// --- Multi-User Moderation and Provenance (MistMulti.js) ---
createProvenance       // Attach provenance to user actions/events

// --- Multi-User and P2P Features (MistMulti.js) ---
addUserSession         // Add user to active sessions with encryption
removeUserSession      // Remove user with proper cleanup
updateUserPresence     // Update user status with timestamp
announceHostSession    // Announce host with DHT integration
discoverHostSession    // Discover hosts via DHT/P2P
generateSessionToken   // Generate secure session tokens
signMessage           // Sign messages with ECC
verifyMessage         // Verify signed messages
onEvent               // Register event handlers
emitEvent             // Emit events to peers
broadcastToPeers      // Broadcast with FEC support
mergeState            // Merge states with conflict resolution
syncStateWithPeer     // Sync state with encryption
encryptMessage        // Encrypt with ECC
decryptMessage        // Decrypt messages
canSendMessage        // Check rate limits
grimReaper            // Monitor tensor anomalies
encodeMessageFEC      // Reed-Solomon encoding
decodeMessageFEC      // FEC message recovery
handleARPointerInput  // Handle AR input mapping

// --- Migration Status ---
// ✓ MySQL integration complete (replacing Google Sheets/Drive)
// ✓ X11 native UI toolkit implemented
// ✓ Vulkan/OpenCL acceleration integrated
// ✓ State persistence using MySQL
// ✓ GPU-accelerated matrix operations
// ✓ Wave/physics logic unified in pureMathPhysicsEngine.js
// ✓ P2P multi-user features implemented
// ✓ Milestone-based mode system active
// ✓ Provenance system implemented
// ✓ AR integration framework added
// - Vulkan window management optimizations ongoing
// - Advanced nD visualization features in progress
// - Additional haptic/AR device support planned

Mist Solution: Use Cases and User Groups

1. Scientific Research & Data Provenance

User Groups:

  • Astrophysicists
  • Physicists
  • Computational scientists
  • Data provenance researchers

Use Cases:

  • Multi-dimensional tracking of experimental or simulation data (e.g., time, category, item, spatial coordinates, and more).
  • Visualizing and simulating nD relationships (e.g., pulsar maps, quantum state spaces).
  • Ensuring full provenance and reproducibility of all data manipulations and analyses.
  • Collaborative annotation and review of scientific datasets.

Why Choose Mist?

  • Native support for nD data and physics simulation.
  • Robust provenance and moderation (every action tracked).
  • Real-time multi-user collaboration.
  • Extensible for custom scientific workflows (e.g., storyWriter for parsing scientific logs or RTFs).
  • No comparable open-source solution combines all these features.

2. Education & Interactive Learning

User Groups:

  • STEM educators
  • Students (secondary, undergraduate, graduate)
  • Museum exhibit designers
  • Science communicators

Use Cases:

  • Interactive, multi-user exploration of complex scientific concepts (e.g., relativity, quantum mechanics, geometry).
  • Visualizing and manipulating 3D/4D/nD objects and relationships in real time.
  • Collaborative problem-solving and annotation in classroom or remote settings.
  • Building educational simulations or games with provenance and moderation.

Why Choose Mist?

  • Flexible UI (X11, CLI, potential for VR/web).
  • Real-time collaboration and moderation for group learning.
  • Extensible modules for custom educational content.
  • Provenance ensures accountability and learning assessment.
  • More advanced nD and provenance features than JupyterLab, OpenSim, or OpenSpace.

3. Digital Humanities & Story-Driven Analysis

User Groups:

  • Digital humanities scholars
  • Literary analysts
  • Archivists
  • Collaborative writers

Use Cases:

  • Parsing and visualizing relationships in stories, historical documents, or literary works (e.g., character interactions over time).
  • Collaborative annotation and discussion of texts.
  • Mapping narrative structures in nD space (e.g., time, location, theme, character).
  • Tracking provenance of edits and annotations.

Why Choose Mist?

  • storyWriter utility for parsing RTF and plain text.
  • Multi-dimensional data model fits complex narrative structures.
  • Real-time collaboration and provenance for scholarly annotation.
  • No comparable open-source tool offers nD visualization and provenance for text analysis.

4. Multi-User Simulation & Virtual Worlds

User Groups:

  • Simulation developers
  • Game designers
  • Virtual world researchers
  • Social scientists

Use Cases:

  • Building collaborative, physics-driven virtual environments.
  • Simulating social or physical systems with nD relationships.
  • Real-time, multi-user interaction with moderation and event tracking.
  • Experimenting with new forms of digital presence and interaction.

Why Choose Mist?

  • Built-in multi-user, P2P, and moderation infrastructure.
  • Physics engines for both UI and world simulation.
  • Extensible for custom simulation/game logic.
  • More scientific and provenance-focused than OpenSim or OpenSpace.

5. Mission Control, Operations, and Data Visualization

User Groups:

  • Space mission planners
  • Operations analysts
  • Data visualization specialists
  • Systems engineers

Use Cases:

  • Visualizing and tracking mission data across multiple axes (time, subsystem, event, etc.).
  • Real-time collaborative monitoring and annotation.
  • Ensuring provenance and auditability of all operational actions.
  • Integrating scientific and operational data for holistic analysis.

Why Choose Mist?

  • Flexible, extensible data model for complex operations.
  • Real-time collaboration and robust provenance.
  • More extensible and nD-capable than OpenMCT or similar tools.

6. Moderation, Security, and Provenance-Driven Systems

User Groups:

  • Moderators and administrators of collaborative platforms
  • Security researchers
  • Compliance officers

Use Cases:

  • Tracking and moderating user actions in collaborative environments.
  • Detecting and responding to anomalous or malicious events.
  • Ensuring compliance and auditability in sensitive workflows.
  • Attaching and verifying provenance for all user actions.

Why Choose Mist?

  • Advanced moderation, anomaly detection, and event horizon logic.
  • Provenance attached to every action.
  • Real-time, multi-user event handling and audit trails.
  • More robust and scientific than moderation in typical collaborative tools.

Summary Table

Use Case Area User Groups Why Choose Mist?
Scientific Research Scientists, Data Provenance nD, provenance, real-time, extensible, unique combo
Education Educators, Students Interactive, collaborative, provenance, nD, flexible
Digital Humanities Scholars, Writers, Archivists Text parsing, nD, provenance, collaborative
Simulation/Virtual Worlds Devs, Game Designers, Researchers Multi-user, physics, moderation, extensible
Mission Control/Visualization Ops, Engineers, Analysts nD, real-time, provenance, extensible
Moderation/Security Moderators, Compliance, Security Provenance, anomaly detection, audit, moderation

Each group should choose Mist for its unique combination of nD data modeling, real-time collaboration, provenance, moderation, and extensibility—features not found together in any other open-source solution.

You list Ubuntu and Fedora, and also X11. Didn’t they both drop X11?

They are certainly planning to. It shouldn’t be a problem if you are using any current LTS version of those distros. I’m just not familiar enough with wayland except for one particularly bad experience using it a while back.
Nothing in this specifically requires any portion of X11, that’s just the only setup that I’ll be testing on for now. I will be migrating to X11Libre once they have a full release put together.

2 Likes

Alright so time for a logical proof for the MistTracker solution. Hopefully my formatting makes sense. It doesn’t need to make sense if it works. Isn’t chaos beautiful?

1. In the beginning there is a single point. a = 01
2. The single point is the entire universe and contains all that there is. u = 1
3. Then I define the primary line of light and distinguish it from dark. t = 0 or 1.
4. From this definition, all other items are defined. 1 = 1
5. Items are projections and reflections of items in the universe. i = 0/1
6. The place where items reside is the universe. 1 = (i^n)!
7. The end of the universe is outside of the universe. e = 1/0

This is pretty cool idea, not sure if it makes sense but a high level knowledge graph index might be interesting to view clusters or topics.

1 Like

I hope this makes more sense to you:

Mist Solution in JS

/\*\*

 \* mistSolution \- Generate an nD universe environment from logical axioms, physics, and data headers.

 \* @param {Object} db \- Database connection (optional, for persistence).

 \* @param {Object} options \- { dimensions, size, user, dictionary }

 \* @returns {Object} \- { universe, objects, categories, dictionary }

 \*/

async function mistSolution(db, options \= {}) {

  // 1\. Logical Axioms (from LogicalProofOfMist.rtf)

  // Universe starts as a single point in nD

  const n \= options.dimensions || 3;

  const size \= options.size || 10;

  let universe \= {

    points: \[Array(n).fill(0).concat({ value: 1 })\], // e.g., \[{x:0, y:0, z:0, value:1}\] for 3D

    description: \`The universe begins as a single point in ${n}D containing all.\`

  };

  // 2\. Define primary line (light/dark axis)

  universe.primaryLine \= \[

    { t: 0, value: "dark" },

    { t: 1, value: "light" }

  \];

  // 3\. Define items as projections/reflections (i \= 0/1)

  let itemCount \= Math.pow(2, n);

  let items \= \[\];

  for (let i \= 0; i \< itemCount; i\++) {

    items.push({

      id: i,

      projection: i.toString(2).padStart(n, '0').split('').map(Number),

      value: 1

    });

  }

  // 4\. Place items in universe (1 \= (i^n)\!)

  let factorial \= (x) \=\> (x \<= 1 ? 1 : x \* factorial(x \- 1));

  universe.size \= factorial(items.length);

  // 5\. End of universe (e \= 1/0)

  universe.boundary \= "outside";

  // 6\. Physics Engine (from pureMathPhysicsEngine.js)

  const {

    generateLandscapeND,

    createVoxelObjectND,

    updateDistanceFromObserverND,

    computeAngularMomentumMapND

  } \= require('./pureMathPhysicsEngine.js');

  // Generate nD landscape

  let landscape \= generateLandscapeND(n, size);

  // 7\. Categories and Dictionary (from mistUpdateHeaders.csv)

  let categories \= \["category", "dictionary", "word", "definition", "item", "documentId", "time", "itemPage"\];

  let dictionary \= options.dictionary || {};

  // 8\. Create objects in the universe

  let objects \= \[\];

  for (let i \= 0; i \< items.length; i\++) {

    // Random nD position

    let pos \= Array.from({ length: n }, () \=\> Math.floor(Math.random() \* size));

    let obj \= createVoxelObjectND(pos, Array(n).fill(1));

    obj.id \= items\[i\].id;

    obj.projection \= items\[i\].projection;

    objects.push(obj);

  }

  // 9\. Observer and physics updates

  const observer \= { position: Array(n).fill(Math.floor(size / 2)) };

  objects.forEach(obj \=\> {

    updateDistanceFromObserverND(obj, observer);

    computeAngularMomentumMapND(obj);

  });

  // 10\. Optionally persist to DB

  if (db) {

    // Save universe, objects, and categories as needed

    // Example: await db.query('INSERT INTO Universe ...', \[ ... \]);

  }

  // 11\. Return the constructed universe

  return {

    universe,

    landscape,

    objects,

    categories,

    dictionary

  };

}

module.exports \= { mistSolution };


1 Like