🌊 Sovwave.jl
v0.4.0 β€’ Official Julia Wave Intelligence Library

Harmonic Wave Intelligence
Without Matrix Multiplications

Sovwave replaces discrete token arrays, binary neural matrices, and Markov chain approximations with continuous wave interference, quantum lattice oscillators (432Hz carrier), and video-native model serialization.

⚑ Quick Install πŸ–₯️ Visual GUI Interface πŸ“– How to Train Models ⭐ Star on GitHub

πŸ“¦ Frictionless Pkg Installation

Install directly into any Julia 1.9+ environment with zero GPU drivers, CUDA, or heavy C-bindings required:

using Pkg
Pkg.add(url="https://github.com/TheProtaganist/sovwave.git")

# Load Sovwave
using Sovwave

πŸ–₯️ Local Visual Quantum GUI

Sovwave comes with a built-in interactive browser GUI powered by Julia's standard library Sockets. Monitor continuous quantum wave lattices in real-time, inspect Potts q-states, run interactive training loops, and sonify tokenized text into audible acoustic waves. 

using Sovwave

# Launch the visual GUI at http://127.0.0.1:8080
launch_gui(port=8080, open_browser=true)

βš›οΈ Live Quantum Lattice

Interactive HTML5 Canvas visualizer showing real-time wave amplitude ripple \(\psi(x, y)\) and phase vectors across the continuous manifold. Supports customizable Potts 3-phase domain state colors (default: state 0 -> #FF00FF Magenta, state 1 -> #FFFF00 Yellow, state 2 -> #00FFFF Cyan).

🌊 Multilingual Wave Sound Engine

Type text, emojis (πŸŒŠπŸ§ βš‘πŸš€βš›οΈ), or any world language (Arabic, Chinese, Japanese, Korean, Hindi, Cyrillic, Hebrew, Greek). Experience physical wave packets played as sound directly through browser speakers via the Web Audio API.

βš™οΈ YAML Configuration Manager

Visual parameter management for lattice dimensions, embedding depth, population size, mutation rates, and Potts state colors. Directly import, export, and hot-reload model_config.yaml.

🧠 Complete Guide: Training & Building Models in Sovwave

A step-by-step walkthrough for constructing multi-modal wave models, formatting datasets, evolving parameters via energy descent, and serializing models as Matroska video containers.

Step 1: Universal Dataset Formatting (Tabular, Text, Image, Audio, 3D)

Unlike PyTorch or TensorFlow which mandate discrete tensor matrices, Sovwave projects arbitrary data into continuous wave harmonic embeddings: 

using Sovwave

# Natural Language / Multilingual Text
texts = ["Quantum harmonic wave computing 🌊", "θ‡ͺε·±η΅„ηΉ”εŒ–ηœŸη©Ίγ¨θͺΏε’Œζ³’ε½’ βš›οΈ", "Ψ°ΩƒΨ§Ψ‘ Ψ§Ψ΅Ψ·Ω†Ψ§ΨΉΩŠ Ω…ΩˆΨ¬ΩŠ ⚑"]
labels = [1, 2, 3]
ds_text = format_text(texts, labels; max_len=16, embed_dim=32)

# Tabular Numerical Data (Matrix -> Continuous Wave Manifold)
X = rand(100, 8)
y = rand(1:3, 100)
ds_tab = format_tabular(X, y; embed_dim=32)

# Batched DataLoader with Shuffling
loader = WaveDataLoader(ds_text; batch_size=16, shuffle=true)

Step 2: Model Configuration & Instantiation

Define lattice resolution, carrier driving frequency (\(\omega = 432.0\text{ Hz}\)), golden ratio scaling (\(\beta_s \approx 1.618\)), and layer topology: 

# Create custom configuration
cfg = WaveMLConfig(
    field = WaveFieldConfig(lattice_size=(32, 32), omega=432.0, beta_s=1.618),
    model = WaveModelConfig(layers=4, embed_dims=32),
    train = WaveTrainConfig(population_size=12, mutation_rate=0.05, generations=50)
)

# Instantiate pure wave neural model
model = WaveModel(cfg)

# Inspect model architecture and continuous parameter count
summary = inspect_model(model)
println("Total Continuous Parameters: ", summary.total_parameters)
println("Total Model Layers: ", summary.num_layers)

Step 3: Evolutionary Ground-State Optimization (train!)

Train without backpropagation or CUDA matmuls. Sovwave explores the Hamiltonian phase space to minimize continuous wave loss and find the global energy ground state: 

# Train the wave model over the dataset
history = train!(model, ds_text; generations=25, verbose=true)

# Access training trajectory
println("Initial Ground Loss: ", history.losses[1])
println("Final Converged Loss: ", history.losses[end])
println("Final Accuracy: ", history.accuracies[end] * 100.0, "%")

Step 4: Inference & Generation Across the 5 Architectures

Generate text, de-interfere 2D images, synthesize 3D radiance fields, or evaluate hallucination-free type-safe decisions: 

tok = default_tokenizer()

# 1. Autoregressive Wave Text Generation
output_text = generate_text(model, tok, "Universal consciousness 🌊"; max_new_tokens=16)

# 2. Continuous 2D Image Synthesis
image_matrix = generate_image(model, "emergent wave crystal"; height=32, width=32)

# 3. 3D Volumetric Radiance Field Synthesis (x, y, z) -> (Οƒ, RGB)
vol_3d = generate_3d(model, "toroidal vortex"; resolution=16)

# 4. Jev Decision Engine (Hallucination-Free Structured Decision)
state = Dict("entropy" => 0.12, "coherence" => 0.98, "active_nodes" => 64)
questions = ["Is lattice coherent?", "Requires energy dump?"]
decisions = jev_decide(model, state, questions)

# 5. Spatio-Temporal Video Generation
generate_video(model, "quantum ripple", "ripple.mkv"; frames=24, fps=6)

Step 5: Lossless Matroska Video Model Serialization (.mkv / .mp4)

Models are serialized losslessly as video files where each frame pixel encodes an evolved continuous wave parameter: 

# Save model to lossless MKV video container
save_model(model, "quantum_model.mkv")

# Load model directly from video container for instant inference
loaded_model = load_model("quantum_model.mkv")
predictions = predict(loaded_model, ds_text.inputs[1])

βš”οΈ Framework Comparison Matrix

How Sovwave compares directly to PyTorch, JAX, NumPy, and Flux.jl:

Feature Sovwave.jl PyTorch JAX NumPy Flux.jl
Computational Core Continuous Wave Fields $\psi(t)$ Discrete Tensors Pure Functions / XLA Multidimensional Arrays Julia Tensors
Optimization Ground-State Energy Evolution Reverse-mode Autograd VJP / Grad None (Manual) Zygote.jl Autograd
Tokenizer Primitive Acoustic WaveForms (Sound & Freq) Discrete Integer IDs Discrete Integer IDs None Discrete Tokens
Model Serialization Lossless Dual-Stream Video (.mkv/.mp4) .pt / .safetensors .msgpack .npy / .npz .bson / JLD2
Model Sonification Native Acoustic Synthesis (WAV/Live) External Libraries None None None
Hallucination Immunity Built-in (Jev Decision Engine) Vulnerable Vulnerable N/A Vulnerable

🎡 Continuous & Phonetic Wave Tokenizer

Type below to observe how text is synthesized into physical acoustic sound waves with IPA formant frequencies \((F_1, F_2, F_3)\) and circular phase angles:

Open Full Tokenizer Demo & Audio Studio β†’

Acoustic IPA Formant Waveforms β€’ Carrier: 963 Hz

🧠 5 Default Native Model Architectures

Sovwave includes 5 native trainable model architectures operating over continuous wave fields:

πŸ“– 1. Wave LLM

Autoregressive sequence modeling predicting next-token continuous wave packets through golden spiral context memory.

out = generate_text(model, tok, "wave packet", max_new_tokens=8)

πŸ–ΌοΈ 2. Image Generation

Continuous 2D spatial surface de-interference synthesizing pixel manifolds from latent harmonic states.

img = generate_image(model, "cymatic pattern"; height=32, width=32)

🧊 3. Text-to-3D

Volumetric radiance fields $(x, y, z) \mapsto (\sigma, R, G, B)$ mapped across continuous coordinate lattices.

vol = generate_3d(model, "sacred solid"; resolution=8)

πŸ›‘οΈ 4. Jev Decision Engine

100% Hallucination-Immune

Jev reads language but never writes it. It ingests an application's data state alongside predefined questions and returns type-safe, structured probabilistic decisions (:boolean, :category, :rubric). Because it cannot generate open-ended text, it is completely immune to traditional text hallucinations. 

decisions = jev_decide(
    model, 
    Dict("temp" => 84.5, "pressure" => 3.2), 
    ["Should cool?", "Risk score?"]; 
    question_types=[:boolean, :rubric]
)

🎬 5. Text-to-Video

Spatio-temporal wave dynamics evolved across frames $t$ and serialized directly to lossless Dual-Stream MKV/MP4 files.

generate_video(model, "vortex dynamics", "vortex.mkv"; frames=16, fps=4)

πŸ† 7x144 Evolutionary Tournament Champions

Every core subsystem was evaluated through a 144-algorithm tournament (12 rounds Γ— 12 candidates, with 6 evolutionary mutations of the previous winner + 6 new unrelated candidates per round):

Subsystem Grand Champion Algorithm Throughput / Latency Physical Metric Score
1. Wave Tokenizer CharLevel_ContinuousFourier_FastEnvelope_QuantumManifold 76.7 Β΅s / packet 100% string accuracy, 1.0 coherence 7,130.31
2. Wave Dataset PottsState_CategoricalProjection_FastPacked16 53.6 Β΅s / 50 samples 100% fidelity, 0.6662 energy var 6,852.06
3. LLM (:llm) FibonacciSpiral_ContextMemory_v2_UltraFastBurst1 8,386.6 tokens/sec (0.6 ms) 0.7273 diversity, 0 hallucination 10,375.12
4. Image Gen ChladniNodal_GridProjection 429,456.1 pixels/sec (0.6 ms) 1.0000 spatial contrast 11,294.56
5. Text-to-3D PlatonicTetrahedral_ResonanceField 134,928.0 voxels/sec (0.47 ms) 1.0000 density variance 12,000.00
6. Jev Engine ChladniNodal_CategorySeparator 2,321.7 decisions/sec (1.72 ms) 100% type safety, 0% hallucination 7,595.38
7. Video Gen LagrangianPhaseFlow_VideoDynamics_v2_HighRes8Frames 1,538.6 frames/sec (5.2 ms) 0.9822 temporal continuity 11,946.46

πŸ” Model Reading & Introspection API

Full visibility into quantum node lattices, learned wave amplitudes, phases, and frequencies:

using Sovwave

model = WaveModel(default_config())

# Read architecture metrics
n_layers = num_layers(model)            # 4
p_count = parameter_count(model)        # 24,836 continuous wave parameters

# Print formatted summary table
model_summary(model)

# Deep inspection of individual layers & disk files (.mkv)
details = layer_details(model, 1)
file_info = inspect_model("trained_model.mkv")