Talos-XII: hand-written autograd + small RL/MLP stack in Rust, applied to gacha probability modeling (no tch-rs/ndarray/PyTorch) — looking for benchmark help on ARM/AVX-512/GPU [P]
Talos-XII is a CLI simulator for Arknights: Endfield's gacha system, built entirely in Rust with a custom autograd engine and small RL/MLP stack (no external ML frameworks). It uses neural networks for environment modeling and pull-decision policy, and includes sophisticated SIMD dispatch and an open experiment called ACHF for adaptive caching.
What it is Talos-XII is a CLI simulator for the gacha system in Arknights: Endfield. Rather than sampling from a static probability table, it trains a small set of neural nets to model environment uncertainty and pull-decision policy, then uses them to answer questions a static table can’t easily express — e.g. “as a F2P player, what’s my probability of getting the rate-up unit on free currency alone?” or “given my current pity count, should I keep pulling or save for the next banner?” Models (trained on first run, ~30-45s, then cached to disk) • EnvNet — small MLP fitting an environment noise/bias distribution, sampled per simulation • Luck Optimizer — neural optimizer over a 32-dim engineered feature vector (pity progress, streaks, interaction terms) • Dueling DQN — discrete pull/wait decision • PPO actor-critic — with an MLA (latent-attention) transformer for continuous strategy Everything underneath is hand-written, no external ML framework: • Custom autograd engine (matmul, conv2d, pooling, norms, gradient-checked backward passes) • Runtime SIMD dispatch: scalar → AVX2 → AVX2+FMA → AVX-512, NEON on ARM64 • Rayon-parallelized sims (~10k+/sec on my laptop) • BF16 inference caches • Optional PyO3 bridge (import talos_xii as tx) for writing training scripts without NumPy/PyTorch • 142 tests, CI on Linux/Windows/macOS with ARM64 cross-compile, single static binary, MIT The part I’m not confident about There’s a component I call ACHF (Adaptive Cache-aware Hyper-Connections): it blends a dense path with a pruned sparse path via a gradient-sensitive gate, adds a manifold (Sinkhorn) weight projection, and switches between cached/sparse/dense execution paths based on measured latency. Loosely inspired by manifold-constrained hyper-connections, but aimed at a different regime — compact RL policies running on CPU inside a single binary, not large-scale training. I don’t yet know if the speed/accuracy tradeoff holds up outside my own machine. I’m treating it as an open experiment, not a result. Where I’d like help I only have access to my own hardware, so my benchmark coverage is thin. There’s an automated benchmark suite in the repo that reports mean ± std with 95% CIs, per-path latency distributions (p50/p90/p99), training curves, and raw CSVs — instructions are in the README. If anyone’s willing to run it on a different CPU (AVX-512, ARM NEON) or GPU setup, I’d genuinely appreciate the data — negative results (ACHF not helping on your hardware) are just as useful to me as positive ones. Repo: github.com/zayokami/Talos-XII Solo project, built to learn Rust + ML fundamentals from scratch. Happy to answer questions about any of the implementation details.
A developer built a from-scratch Rust inference engine with custom GPU kernels that outperforms vLLM on Nemotron-30B decoding, achieving 75.7 vs 57 tok/s, submitted to the Build Small hackathon.
Dirge is a Rust-based agentic harness that helps smaller AI models punch above their weight by reducing memory footprint and intelligently managing errors, context, and tool calls, closing the performance gap with frontier models.
Neural_avb releases a lightweight Answer-eq Reward Model for RL training on QA tasks, claiming 80% agreement with external judge LM and faster than F1/ROUGE/BertScore.
A developer built a 12M parameter LLM using a custom ML framework with a Rust backend and CUDA kernels, including Flash Attention and AdamW, and trained it from scratch.