DEV Community: Okerew

[Boost]

Okerew — Sun, 28 Jun 2026 08:37:52 +0000

Jun 26

Update v1.3 for gpumkat

1 min read

Update v1.3 for gpumkat

Okerew — Fri, 26 Jun 2026 18:09:09 +0000

Added support for MTLTexture image buffers, generally improved image buffer logic, fixed bugs
https://github.com/MetalLikeCuda/gpumkat

[Boost]

Okerew — Thu, 25 Jun 2026 09:05:57 +0000

Okerew

Jun 20

Updated osxiec to version v1.1

#c #osx #native #containers

2 min read

Updated osxiec to version v1.1

Okerew — Sat, 20 Jun 2026 04:54:46 +0000

Added a reaper.c - kqueue-based process reaper for container teardown:

The container spawns child processes from several places: foreground
commands (execute_command), background tasks (background_command_thread),
scheduled tasks and start-config scripts. Without a reaper, anything those
children spawn keeps running after the container exits.

Cleanup combines two mechanisms:

Process groups. Background tasks lead their own process group (setpgid),
so a single killpg() takes down the whole subtree they spawned without
having to enumerate it. This is what guarantees long-lived background
work is cleaned up.
- A kqueue EVFILT_PROC / NOTE_EXIT watch on every process we register, so the reaper keeps an accurate live set and can signal exactly what is still running at shutdown (SIGTERM, a short grace period, then SIGKILL).

NOTE_TRACK (which would let the kernel follow forks down the tree via
NOTE_CHILD) is intentionally NOT used: it returns ENOTSUP on modern macOS
(verified on Darwin 25 / macOS 26). Fork-tree following therefore relies on
process-group inheritance instead - descendants stay in their ancestor's
group unless they setsid() away.

We intentionally do NOT waitpid() in the reaper loop. Direct children are
reaped synchronously by their existing waiters (execute_command and the
background-task threads); reaping here too would race them and steal exit
statuses. The reaper only drains leftover zombies during shutdown, once the
interactive loop and those waiters are gone.

Added a mDNSResponder socket proxy:

The sandbox profile applied to the container denies everything by default,
so processes inside it cannot reach the host's /var/run/mDNSResponder UNIX
socket and DNS / Bonjour resolution fails. This proxy listens on a socket
inside the container's filesystem (/var/run/mDNSResponder)
and relays each connection to the real host daemon. Container processes are
pointed at it through the DNSSD_UDS_PATH environment variable, which the
dns_sd client library honours instead of the compiled-in default path.

The dns_sd UDS protocol passes file descriptors between client and daemon
using SCM_RIGHTS ancillary messages, so the relay forwards both the payload
bytes and any descriptors; a byte-only relay would drop the passed fds and
silently break DNSServiceProcessResult() callbacks.

Improved logging, fixed bugs, made network creation and cleaning more viable, restructured code to be more readable. Fixed the terminal after a long time to finally be viable.

https://github.com/Okerew/osxiec

[Boost]

Okerew — Tue, 16 Jun 2026 18:50:23 +0000

Okerew

Jun 13

Released larkos 0.3

#showdev #ai #deeplearning #machinelearning

2 min read

Released larkos 0.3

Okerew — Sat, 13 Jun 2026 15:56:54 +0000

Larkos 0.3: GAT neuron reasoning, temporal encoder, refactored fusion head

Core architecture changes:

Add _NeuronGraphReasoner: two-layer GAT over the live neuron graph,
producing per-neuron token embeddings (MAX_NEURONS x FUSE_GRAPH_DMODEL).
Node features include state, output, layer one-hot, connection degree,
state velocity, output magnitude, and mean edge weight (D_NODE=8).
Learned per-neuron embedding ensures distinct tokens for symmetric nodes.
Add _GATLayer: hand-rolled multi-head GAT with edge-weight-modulated
scores (tanh-squashed gain), dense [N,N] adjacency mask, and self-loops.
Add _TemporalAttentionEncoder: two-layer transformer over the
[TEMPORAL_WINDOW, FOURIER_OUT_DIM] input history with learned positional
embedding, replacing flat concatenation of window frames.
Refactor _FusionTransformerHead: attends over MAX_NEURONS+3 token
sequence (GAT tokens + band_q + band_m + driver). Token-type embeddings
(4 types) distinguish token kinds. Replaces mean-pool with learned-query
attention pool (single query, softmax over sequence). Head capacity
increased: 3 layers, d_model=64, dim_ff=128.
C-side fusion (fusion_mechanism.c):

Remove BAND_N and the neuron_flat projection pipeline; neuron reasoning
is now handled end-to-end by the Python-side GAT.
BAND_Q=32, BAND_M=32, FUSION_DIM=BAND_Q+BAND_M=64.
MEM_TOP_K: 8→32, MAX_MEM_ENTRIES: 300→1200.
Training loop:

Freeze cache extended to cover driver embedding (_cached_driver) and
GAT inputs (_cached_graph_inputs). All three caches invalidated together
on target refresh. GAT runs forward_from_inputs in-graph every step
(pinned inputs, live gradient).
x_temporal detached before MAML inner loop to prevent double-backward
through the temporal encoder graph.
graph_reasoner and temporal_encoder added to optimizer and checkpoint.
Verifier re-runs temporal_encoder on cached raw sequence to avoid
reusing a consumed autograd graph.
LR sensitivity check uses relative threshold (15% of current loss)
instead of fixed absolute delta.
Runner:

Add _advance_backend(): runs C-side decision/context/neuron/attractor/
affective updates before each step() so multi-step inference sees
evolving state.
alpha and mem_weight_ratio derived from live backend context by default,
matching the training loop's per-epoch derivation.
Temporal encoder and graph reasoner included in forward path.
Checkpoint:

Saves/loads graph_reasoner and temporal_encoder (strict=False for
backward compatibility with pre-0.3 checkpoints).
FUSION_DIM and fused_cog_norm dimension mismatch detection with safe
fallback to fresh init.
cached_driver persisted alongside cached_fused_cog.

https://github.com/Okerew/larkos_models

Updated larkos_0.1 to larkos 0.2

Okerew — Wed, 10 Jun 2026 17:08:40 +0000

Larkos 0.2: Major optimizations and architectural improvements

MAML inner-loop refactor: Replaced copy.deepcopy(model) every epoch with a persistent fast_model clone refreshed via per-parameter copy, plus a custom EmbeddingProjector.deepcopy that shares the frozen 22M-param MiniLM across clones instead of duplicating it. Reduces per-epoch deepcopy cost from 22M params to only the small trainable subset.
ST encode caching: Cached the last SentenceTransformer output so re-encoding the same embed_ctx string (~15x per epoch) only fires when the string actually changes.
Adaptive MC dropout: Reduced MC samples 3× when no Gaussian exploration noise is injected (non-exploring epochs), cutting MC cost ~3× on quiet epochs.
FUSION_DIM (64) text prefix: Widened the decode prefix source from MAX_NEURONS (8) to FUSION_DIM (64), giving 8× more source variance to GPT-2 for the same cost. Prefix is now rescaled to wte's mean/std so GPT-2 receives in-distribution embeddings rather than random-projection noise.
distilgpt2: Replaced gpt2 with distilgpt2 (same hidden dim 768, half the params, ~2× faster generation); text is a debug readout so the quality drop is irrelevant.
Adam → AdamW: Corrected weight decay regularization — Adam folds WD into the gradient before adaptive scaling (under-regularizes); AdamW applies it directly to weights.
Anchor text in decode: Fed the actual driver sentence to GPT-2 as real text context rather than steering blind from a bare BOS token.
Safe reflection: Capped _step_counter at _history_count to prevent C-side out-of-bounds access in performSelfReflection.
Graceful cross-architecture checkpoint transfer: Added start_training_from() with _expand_copy() partial weight transfer for upscaling to larger model dimensions; load_checkpoint now uses strict=False and filters EMA shadow keys to match the live model, dropping obsolete keys gracefully.
Robust scenario selection: Added nout == 0 guards and best_idx < 0 fallback to prevent crashes when no scenarios have outcomes.
Removed stale input tracking: Dropped dead add_memory_step / update_meta calls from receive_predictions.
Relaxed test thresholds: Adjusted adaptation, grounding, and physics-test RSA thresholds to account for constant-mass-channel bias and realistic effect sizes; made recovery tolerance configurable.
README updated to Larkos 0.2 with note about previous model versions in source.

In https://github.com/Okerew/larkos_models

[Boost]

Okerew — Tue, 09 Jun 2026 15:34:28 +0000

Okerew

Jun 2

Introducing Cognitive Fusion in Larkos: A Unified Architecture for LLM, Neuron, Memory, and Module Integration

#ai #c #python #architecture

3 min read

Patch 1 and 2 for larkos

Okerew — Mon, 08 Jun 2026 05:09:14 +0000

Patch 1 for larkos 0.1 - Major improvements in testing, fixed bugs added a feature to combine test checkpoints
Patch 2 for larkos 0.1 - bug fixes, addes start_training_from
https://github.com/Okerew/larkos_0.1

Also bug fixes for https://github.com/Okerew/larkos

mCemm a GEMM (General Matrix Multiply) kernel generato

Okerew — Fri, 05 Jun 2026 15:36:03 +0000

Released mCemm a GEMM (General Matrix Multiply) kernel generator for Apple Metal which generates optimized Metal shaders with configurable tile sizes, warp sizes, data types (f16/f32), transpose modes (NN/NT/TN/TT), activations (ReLU/GELU/SiLU), bias and more - https://github.com/MetalLikeCuda/mCemm

Fixed installation in https://github.com/Okerew/osxiec and https://github.com/MetalLikeCuda/gpumkat

Released https://github.com/MetalLikeCuda/awesome-mlc a list of community maintained metal tools, frameworks, libraries and resources.

Introducing Cognitive Fusion in Larkos: A Unified Architecture for LLM, Neuron, Memory, and Module Integration

Okerew — Tue, 02 Jun 2026 14:28:29 +0000

Introducing Cognitive Fusion in Larkos: A Unified Architecture for LLM, Neuron, Memory, and Module Integration

Author: Witold Warchoł

Date: 2.06.2026

See this paper for a more comprehensive version of this post.

Abstract

The Cognitive Fusion Mechanism (CFM) in Larkos integrates LLM embeddings, neuron states, and episodic memory into a shared 64-dimensional space. It ensures information preservation, stream balance, and deterministic reproducibility, enabling dynamic, context-aware reasoning. Empirical results demonstrate strong performance in learning efficiency, domain transfer, continual learning, and meta-learning, while maintaining stability and affective coherence.

Introduction

Current AI systems struggle with catastrophic forgetting, poor generalization, and inefficient adaptation. CFM addresses these by unifying heterogeneous information streams into a cohesive cognitive architecture, validated through a 9-test framework.

Core Architecture: Cognitive Fusion Mechanism (CFM)

Input Streams

LLM Query Stream: Dense embedding vector (q_raw ∈ ℝ^d_llm) from the LLM, blended with text input embeddings at 50% strength.
Neuron Stream: Flattened vector (n_flat ∈ ℝ^16N) for up to 8 active neurons, capturing state, output, connections, and topology.
Memory Stream: Up to 300 episodic entries, each with:
- A 22D vector (prior neuron states + external features).
- Importance weight (α_i).
- Timestamp (τ_i).

Projection Mechanism

Deterministic Random Projections: Maps arbitrary-dimensional inputs to 64D using a splitmix64-style hash, ensuring:
- Dense mixing (all input dimensions influence output).
- No information loss (no blocking/striding).
- Reproducibility (fixed seeds across runs).
Full Projection: Scales input by 1/√n (Johnson-Lindenstrauss lemma).
Banded Projection: Projects into disjoint bands of the 64D output (seeds: 1009, 2003, 3001).

Processing Pipeline

LLM Query Processing: Project + layer-normalize; blend with text input.
Neuron Feature Extraction: Project + normalize flattened neuron vector.
Top-K Memory Attention: Select top 8 memory entries via dot-product similarity; softmax-normalize scores.
Banded Assembly: Re-project each stream into disjoint 64D bands:
- LLM: [0:22]
- Neurons: [22:43]
- Memory: [43:64]
Cross-Band Mixing: Introduce interactions between bands via sigmoid-modulated mixing.
Output Normalization: Layer-normalize the final vector.

Design Rationale

Deterministic Projection: C-side fusion is a feature extractor (not a learner); gradients are killed at the C boundary.
Banded Architecture: Prevents stream dominance (e.g., neurons/memory burying LLM queries).
Top-K Memory Attention: Ensures peaked, informative attention (avoids uniform noise averaging).
Orthogonal Subspaces: Separate seeds for each band guarantee stream independence.

Key Results

Test	Status	Key Metric
Learning Efficiency	PASS	Total Improvement: +0.4770
Domain Transfer	PASS	Transfer Efficiency: +0.6388
Continual Learning	PASS	Forgetting Index: +0.2477
Discovery	FAIL	Variance Ratio: +0.1634
Model Stability	PASS	Loss Late Std: +0.0194
Internal World Model	PASS	Fused Dimensionality: 1.0
Adaptation Speed	PASS	Recovery Epochs: 5
Meta-Learning	PASS	Slope Trend: +0.0045
Affective Representations	PASS	Affective Complexity: +1.1916

Analysis Highlights

Rapid Convergence: 77% loss reduction in early epochs (Test 1).
Robust Transfer: 63.88% efficiency in domain adaptation (Test 2).
Continual Learning: Low forgetting index (0.2477) and fast recovery (Test 3).
Stability: Low loss variance (0.0194) and full dimensionality (Test 5).
Meta-Learning: Improving slope trend (+0.0045) shows "learning to learn" (Test 8).
Affective Coherence: High arousal correlates with high loss (Test 9).

Conclusion

CFM enables robust, interpretable, and adaptive cognitive modeling by unifying LLM embeddings, neuron states, and memory. It addresses catastrophic forgetting, poor generalization, and inefficient adaptation, paving the way for human-like AI systems. Future work will focus on scaling and refining exploration-exploitation balance.

Released reminders-sync, bug fixes for neural web

Okerew — Thu, 28 May 2026 08:17:25 +0000

Released a simple neovim plugin which allows pulling reminders to a certain directory, and editing them, while automatically pushing to macOS Reminders app.
https://github.com/Okerew/reminders-sync

Made simd work better, made it actually usefull, added loadNetworkStates, fixed bugs in https://github.com/Okerew/larkos