Explore the Oscilon Ecosystem

Production-focused tools and extensions prioritized for mission-critical industries and edge use cases

Oscilon provides a tightly integrated, lightweight ecosystem built around deterministic Evolutionary Adaptive Intelligence (EAI). Every component is designed for performance, portability, and reliability on heterogeneous hardware—from high-end workstations to rugged edge nodes—while maintaining strict determinism through targeted mutations and fitness thresholding.

Below is a detailed breakdown of each core pillar in the ecosystem.

1. Oscilon-Core

C++17 header-only framework for building and evolving deterministic EAI models

The heart of Oscilon is a modern, header-only C++17 library that lets you define, load, mutate, and evolve neural networks with full control and zero external runtime dependencies (no Python, no heavy frameworks).

Key features

Sparse node identification via lightweight error scanning (scalar-level loss contribution)
Targeted GA-based mutations applied only to flagged nodes (weight perturbation, connection prune/add, activation swap)
Deterministic fitness evaluation with user-defined or built-in strict thresholds—no probabilistic acceptance
Compact in-memory representation optimized for low-latency forward passes on edge hardware
Seamless serialization to/from .osm format for deployment

Typical workflow (simplified)

cpp

#include <oscilon/core.h>
oscilon::Network net = oscilon::load("baseline_tdl.osm");
oscilon::ErrorScanner scanner(net);
auto error_nodes = scanner.identify(threshold = 0.05);

oscilon::Mutator mutator(net);
mutator.apply_targeted_mutations(error_nodes, strategy = "weight_perturb");

oscilon::FitnessEvaluator eval(threshold = 0.001);
if (eval.evaluate(net) >= eval.threshold) {
	mutator.commit();  // Deterministic commit
}
net.save("refined_model.osm");

When to use

Anytime you need fine-grained control over evolution, want to integrate EAI into an existing C++ codebase, or require maximum portability across platforms (Windows, Linux, macOS, iOS, Android, embedded Linux).

2. Accelerators

Native acceleration on AMD ROCm/HIP, Microsoft DirectML, Apple Metal, NVIDIA CUDA (via portability), and FPGA offload

Oscilon parallelizes the most expensive operation—fitness evaluation of candidate mutations—across available hardware without breaking determinism.

Supported backends

AMD GPUs → ROCm/HIP (Linux), DirectML (Windows)
Apple GPUs → Metal (macOS/iOS)
NVIDIA GPUs → CUDA (native or HIP portability layer)
AMD Zynq™ UltraScale+™ MPSoCs → FPGA kernel offload via Xilinx tools
CPU fallback → OpenMP multi-threading for baseline parallelism

Unified API

cpp

oscilon::DistributedContext ctx("cuda");     // or "rocm", "metal", "directml", "fpga"
ctx.spawn_workers(device_ids = {0, 1, 2, 3});
ctx.parallel_evolve(net, generations = 150); // Distributed deterministic cycles

Benefits

Near-linear scaling on multi-GPU setups for rapid refinement
Low-power, low-latency execution on mobile/embedded (Metal, Jetson CUDA, Zynq FPGA)
Determinism preserved: strict seeding + ordered evaluation

3. Oscilon Data Pipelines

Zero-copy streaming for edge sensors and real-time tactical data

Lightweight, header-only pipeline system tailored for heterogeneous, real-time inputs common in mission-critical edge scenarios (sensor streams, TDL message feeds, EW signals).

Key features

Zero-copy buffer mapping from device I/O (e.g., direct DMA from tactical radios)
Deterministic preprocessing transforms (normalization, missing-value imputation with fixed strategies)
Single-sample streaming mode optimized for low-latency inference
Unified tensor-like views for multimodal data (time-series, categorical, sparse)

Example

cpp

oscilon::data::Pipeline pipeline;
pipeline.add_source<oscilon::data::SensorStream>("radio:/link16");
pipeline.add_transform<oscilon::data::Normalize>();
pipeline.add_transform<oscilon::data::DeduplicateJitter>(window_ms = 50);

auto sample = pipeline.next();  // Single real-time sample
net.forward(sample);

Use cases

Real-time TDL message ingestion and classification
Adaptive fusion of noisy multi-sensor feeds
On-device refinement using local tactical data

4. .osm Format

Compact binary serialization optimized for embedded deployment

Oscilon models are saved in a custom, dense binary format (.osm) designed for minimal size and fast loading on resource-constrained devices.

Features

Typically 10–100 KB for sparse EAI networks (vs. MBs for dense models)
Full preservation of network topology, weights, and mutation history
Checkpoint support with metadata (iteration, fitness score, mutation log)
Cross-platform endianness handling
Optional compression for ultra-low-bandwidth transfer

API

cpp

net.save("mission_model.osm");                    // Full model
net.save_checkpoint("iter_120.osm", 120, fitness); // With metadata

5. Oscilon Evolver

High-level orchestrator for sparse, deterministic evolutionary cycles

A convenient abstraction layer that ties together scanning, mutation, evaluation, and commitment into repeatable, configurable cycles.

Features

Configurable parameters: max generations, mutation budget, early-stop criteria
Built-in convergence monitoring (plateau detection, fitness stagnation)
Logging of every committed mutation for traceability
Integration with accelerators and data pipelines

Example

cpp

oscilon::Evolver evolver(net);
evolver.set_max_generations(500);
evolver.set_fitness_threshold(0.0005);
evolver.set_mutation_budget_per_cycle(0.03);  // 3% of nodes

evolver.run();  // Runs until convergence or max generations

6. Built-in Profiler

Monitor mutation efficiency and convergence on target hardware

Lightweight, zero-overhead profiler to measure real-world performance during evolution.

Features

Per-cycle timing (scan, mutate, evaluate, commit)
Node-level hotspot analysis (which nodes are mutated most frequently)
Convergence curve tracking (fitness over generations)
Hardware-specific metrics (GPU utilization, memory bandwidth)
Export to CSV/JSON for external analysis

Example

cpp

oscilon::Profiler prof;
prof.start();
evolver.run();
prof.end();

prof.report();  // Prints summary: avg cycle time, mutation efficiency, etc.