HackerNews Digest

Ultramarine 1 Flash is presented as a professional‑grade, “Fable‑class” language model targeting finance, law, consulting, and operations tasks. It claims 60 × lower cost than the Claude Fable baseline and delivers higher scores on the internal “PI Knowledge Work” benchmark, which evaluates completed Excel workbooks, PowerPoint decks, Word documents, and interactions with ERP/MES systems using a rubric of substance, accuracy, and presentation. Across six benchmark suites, Ultramarine 1 Flash produces 6.5 % fewer tokens than its predecessor GLM‑5.3 Flash, reducing latency and cost. Pricing is quoted at $0.13 per task (input $0.15, cached input $0.03, output $0.50), comparable to GLM‑5.3 Flash’s per‑million‑token rate, and substantially cheaper than Claude Fable 5 ($8.19/task) and GPT‑5.6 Sol ($2.09/task). The model emphasizes clean, straightforward prose and adherence to professional visual and information hierarchy standards. Technical details and a full evaluation are referenced in an accompanying report.

llmspeed provides pre‑purchase performance estimates for running short prompts on local large language models. The site organizes data by hardware configurations and by specific model types, allowing users to compare expected latency on a single device. Speed figures are derived primarily from community benchmarks such as r/LocalLLaMA and localscore.ai; additional entries are extrapolated from comparable hardware setups or spec‑based projections. All methodology and code are openly available on GitHub, enabling verification and further contribution. The platform serves as a practical reference for assessing local LLM responsiveness before acquisition.

PS5LM is a home‑brew application for jail‑broken PlayStation 5 consoles (firmware 7.00‑13.60) that runs llama.cpp’s Vulkan backend directly on the console’s RDNA 2 GPU. It loads GGUF‑formatted language or decision models into up to 11.4 GB of shared memory, then exposes them as a private API server reachable at http://<console>:8081. Supported endpoints include OpenAI‑compatible /v1/chat/completions, Anthropic‑compatible /v1/messages, and Ollaya‑style decision‑model endpoint /v1/systemone, returning typed choices, scores, and yes/no answers in a single forward pass. The UI, displayed on the TV, streams request logs, shows real‑time temperature, power, and load charts, and allows model selection from a curated list or manual GGUF uploads (local storage, M.2, or USB). Image‑capable models (e.g., Gemma 4, MiniCPM‑V, d1) can process pictures within chat or decisions. Installation involves copying the PPSA99575 payload to /data/homebrew via FTP and placing GGUF files in /data/PS5LM/models. The project is GPL‑3.0‑or‑later (payload) with llama.cpp under MIT; no Sony SDK files or model weights are included.

Claude, an Anthropic research model, identified the provenance of the seed values used for the NIST ECDSA curves (P‑192, P‑224, P‑256, P‑384, P‑521 and several binary curves). By scanning the 20‑byte seeds for patterns matching outputs of the 1990s C library linear‑congruential generator lrand48, Claude reconstructed the generator’s internal state and determined that each seed was produced by lrand48 initialized with a Unix timestamp (or half‑timestamp for binary curves). The required number of iterations ranged from hundreds to thousands (e.g., 1842 for P‑256). This explains the seeds without invoking any secret hash or backdoor, confirming that the curves were generated from a simple, reproducible PRNG. Claude also traced the base‑point generation for six early curves to the FreeLIP/NTL random‑number generator using small integer seeds. Unexplained aspects remain: some candidate seeds were skipped, the B‑163 binary seed is still unknown, and the base points for P‑224, P‑256, P‑384, and P‑521 have not been linked to a documented process.

The post models linear layers, MLPs, and self‑attention as associative memory stores that hold key‑value pairs ((k_i,v_i)).
Outer‑product store (linear layer) stores memories via (W=\sum v_i k_i^\top). Recall is (f(x)=\sum v_i (k_i^\top x)); interference grows as (\sqrt{M/d_k}), giving a capacity ≈ (d_k).
Optimal linear store solves a least‑squares regression, yielding (W=V^\top K(K^\top K)^{-1}). Whitening the keys reduces interference, raising capacity to ≈ (2d_k).
MLP as nonlinear store applies a gating nonlinearity (\sigma) to similarities: (f(x)=\sum v_i \sigma(k_i^\top x)). Using ReLU, squared ReLU, or higher‑order powers (p) suppresses low‑similarity contributions, expanding capacity to (\Theta(d_k^p)) (e.g., ≈ 2.7 k for (p=2) with (d_k=64)).
Self‑attention replaces (\sigma) with softmax: (f(x)=V^\top \text{softmax}(\beta Kx)). With (\beta=\sqrt{d_k}), capacity grows exponentially, ≈ (e^{2\beta(1-\beta/d_k)}) (~1 M memories for (d_k=64)). Scaling (\beta) as (\log M) (Su, YaRN, Qwen) permits effectively unbounded context lengths.

Capacities are measured by the interference‑to‑signal ratio; higher‑order or exponential gating dramatically reduces interference, enabling far more memories per layer.

Lingua Franca is presented as a language framework that enables deterministic concurrency across both multi‑threaded and distributed systems. By abstracting low‑level thread management, it removes the need for developers to manually handle synchronization primitives, thereby preventing race conditions. The approach guarantees that program behavior is repeatable regardless of execution order, facilitating reliable parallel computation without the typical complexities of concurrent programming. This deterministic model applies uniformly to any target programming language, allowing developers to write concurrent code without language‑specific concurrency constructs while preserving correctness and predictability.

The page reports that a required component could not load. It attributes the failure to possible browser extensions, network problems, or browser configuration issues. Users are instructed to verify their internet connection, temporarily disable any ad‑blocking or similar extensions, and, if necessary, attempt to view the site with a different browser. No further content or technical details are provided beyond these troubleshooting suggestions.

The article explains a new PyTorch activation‑memory‑budget solver, dp_knapsack_sliding_hirschberg, which replaces the default dp_knapsack dynamic‑programming (DP) 0/1 knapsack implementation. The original solver builds a full DP table of size (items × capacity), causing high peak RAM usage and requiring back‑tracking to recover the selected items. The new solver applies two optimizations:

• Sliding‑window trick – keeps only two rows (previous and current) of the DP table, reducing memory from O(items × capacity) to O(capacity).
• Hirschberg divide‑and‑conquer – recursively splits the item set, computes left/right DP rows with the sliding window, combines them to locate the optimal split, and directly builds saved‑vs‑recomputable item lists, eliminating explicit back‑tracking.

These changes lower peak RAM by ~20× (e.g., handling 2000 items on a 64 GB machine versus failure at ~100 items) and yield ≈37 % runtime improvement. Solver choice guidance: use greedy_knapsack for speed, ilp_knapsack (SciPy) for fast exact solutions, dp_knapsack for default PyTorch builds, or dp_knapsack_sliding_hirschberg for memory‑constrained environments. Usage involves setting fconfig.activation_memory_budget_solver = fconfig.dp_knapsack_sliding_hirschberg.

FLUX 3 Image Klein is an open‑weights text‑to‑image model with 5.6 B parameters, supporting native 4K generation, pixel‑perfect editing, and bounding‑box control for up to ten reference images. It builds on multimodal FLUX 3 learnings (image spatial detail, video motion, audio event cues) to produce grounded visuals. The release includes a base checkpoint for fine‑tuning (LoRA support via Diffusers and NVIDIA NeMo) and a step‑distilled version for low‑latency inference, provided in FP8, INT8, and NVFP4 formats under the FLUX Kommunity License. The generator weights occupy 11.2 GB (BF16) or 5.6 GB (FP8); the INT8 build runs on GPUs with ≥8 GB VRAM. Benchmarks show a 1 MP image generated in ~4 s on RTX 5090 and <9 s on RTX 4070 (distilled model), with NVFP4 achieving <0.6 s on NVIDIA GB300. Internal evaluations rank the model first among open‑weights systems in text‑to‑image, multi‑reference generation, and editing, surpassing larger models (e.g., Qwen‑Image 2.1, FLUX 2 klein). Commercial use is free for entities with ≤$5 M revenue; larger users require a separate license. Safety mitigations include dataset filtering, targeted fine‑tuning, and external red‑team assessment.