HackerNews Digest

None

The document lists a series of images under the title “help i accidentally a wigglegram.” For each of the 24 images, only brief alt‑text descriptions are provided, such as “c.”, “scrollin’”, “slowly, slowly”, “ten seems like a good boundary”, “plausible…”, “space mountain?”, “block island”, “deland”, “probably also disney?”, “notting hill”, “perugia”, “cat”, “another cat”, “dog”, “pigeon”, “ipad sidecar I should write on”, “baby book”, “same but doing a rad flip”, “resistor bridge”, “leg in pieces”, “olivetti”, “charlotte?”, “frog with a joint”, and “and happy birthday ig”. No additional narrative, metadata, or context is included beyond these captions. The content is purely a sequential enumeration of image identifiers and their corresponding short descriptive phrases.

APERTVS.ai is presented as a fully open AI platform: all training data, code, model weights, methods, and alignment principles are publicly documented and reproducible, positioning the project as the “Open” equivalent for AI development. The system is engineered to comply with the EU AI Act at scale, incorporating mechanisms for user opt‑outs, automatic removal of personally identifiable information, and safeguards against memorization, thereby providing a globally applicable foundation. Performance claims state that the models are competitive with leading open‑source alternatives at both 8 billion‑parameter and 70 billion‑parameter scales, and they support multilingual operation from inception, having been trained on over 1,000 languages. Swisscom is identified as a strategic partner within the Swiss AI Initiative.

The Sakana Fugu experiment used the AutoResearch framework to let an AI agent iteratively rewrite a small GPT’s training code, run experiments, and retain only changes that reduced validation bits‑per‑byte (BPB). Over ~14 h on a single H100 GPU the agent executed 123 trials, achieving a mean BPB of 0.9774 ± 0.0019 (best single‑run 0.9748), surpassing three frontier baselines (Model C 0.9781, Model B 0.9793, Model A 0.9822). Subsequent case studies showed Fugu‑Ultra consistently out‑performing the same baselines: * Classical Japanese kana reading‑order task: NED 0.80 vs. Model A 0.24, Model B similar, Model C none. * Rubik’s‑Cube solver (300 scrambles, pure Python): solved all cubes, averaging 19.72 moves (Model A 19.76); Models B/C crashed. * Mechanical iris CAD: generated functional, gap‑free blade mechanism; other models produced defective designs. * Blindfold chess (four games against three frontier models and a 2100‑Elo Stockfish): Fugu secured checkmate in each game. * Anonymous stock‑trading benchmark (50‑week window, $10 k start): portfolio grew to $11 943 ± $634 (+19.43 % mean); all other models remained < +15 %. These results suggest that coordinated multi‑agent research can exceed the performance of individual frontier models across diverse domains.

The author, a Danish libertarian privacy activist and former police officer, recounts an arrest following the online publication of two numbers he encoded in letters—claimed to be Prime Minister Mette Frederiksen’s social‑security and phone numbers—and a screenshot of an attempted interview about her stance on encryption and expanded police data access. Armed, masked officers entered his residence without prior warning, forced entry, and immediately disabled the circuit‑breaker panel to cut power to his router. They also removed his Google Nest cameras, which store footage locally, thereby preventing recording of the arrest beyond a brief pre‑cut segment. The author states that Danish law permits filming police, and he alleges the officers refused to disclose charges, which he considers illegal. He expresses concern that such tactics undermine transparency and privacy rights in Denmark and the broader West.

Memory‑safe inline assembly is a pre‑release feature of Fil‑C (not in 0.679) that lets programmers use GCC/Clang‑style asm while preserving the language’s safety guarantees. The compiler emits the assembly template and constraints as LLVM IR strings, then a safety pass (FilPizlonator) parses them. It rejects any snippet containing memory accesses, control‑flow, or unrecognized instructions; it also validates that all register and flag side‑effects are listed in the constraints. Allowed instructions are those with no side‑effects beyond registers (e.g., `sar`, `shr`, `and`, `shl`, `xor`, `mov`, `test`, `cmp`, `bsf`, `cmov`, `cpuid`, `xgetbv`) and their required clobbers. Blank asm blocks remain trivially safe, and “+r” constraints on pointers are supported via LLVM IR threading. Unsafe asm causes a runtime panic with diagnostics; unsupported CPU features trigger an illegal‑instruction trap. The implementation includes an AT&T‑syntax parser, an allow‑list database, enhanced constraint parsing, and comprehensive tests (including OpenSSH sntrup761). Fil‑C thus becomes the first language with memory‑safe x86‑64 inline assembly, covering hundreds of safe instructions.

The article proposes viewing logarithms as “baseless” objects \(\log N\) that acquire numeric value only when divided by another logarithm, e.g. \(\log_b N=\log N/\log b\). This treats change‑of‑base as a unit conversion, analogous to expressing a geometric vector in different coordinate bases. The baseless log functions like a displacement vector: \(\log N\) is the point, while \(\log N/\log M\) is the coordinate component relative to the chosen base \(M\). Similar projection operations appear in number theory (the \(p\)-adic valuation \(\nu_p\) extracts the coefficient of \(\log p\) in the prime‑factor expansion) and complex analysis (the order of vanishing \(\operatorname{ord}_a f=\lim_{z\to a}\log f(z)/\log(z-a)\)). Translation operators satisfy \(T^{\mathbf v}=e^{\mathbf v\cdot\partial}\), so vectors can be identified with logarithms of translations: \(\mathbf v=\log_T T^{\mathbf v}\). The natural logarithm also arises as a derivative limit \(\ln x=\lim_{a\to0}(x^{a}-1)/a\). Finally, the dimension function on finite‑dimensional vector spaces obeys the same additive and multiplicative rules as logarithms, suggesting \(\dim\) is a logarithmic operator.

Linux and open‑source software have matured; most productivity tools now offer reliable web apps, reducing the historic compatibility gap with Windows. Proprietary large language models (LLMs) such as Claude and GPT still dominate performance leaderboards and provide stable, well‑documented APIs that many users trust for handling confidential queries. Open‑source LLMs are typically accessed via third‑party services (e.g., OpenRouter), which raise privacy concerns, or are self‑hosted, a solution that incurs higher cost, complexity, and slower inference. Recent policy changes—Claude’s ID‑verification rollout and tightened safeguards—could restrict professional use of top models without verification. However, the author notes that open‑source models have narrowed the performance gap, trailing the leaders by only a few months, and existing tooling now supports local or cloud deployment. While a short‑term productivity dip is anticipated when shifting away from proprietary APIs, the author expects the impact to be manageable and not a decisive barrier, similar to past transitions from proprietary to open software.

A personal chatbot project uses Retrieval‑Augmented Generation (RAG) for household queries, narrowing vector search by first classifying each question into a predefined metadata category (e.g., pool, car, hvac, cooking). Two local LLMs are employed: Qwen 3 4B for answering and Qwen 3 0.6B (600 M parameters) for classification. An initial dataset of ~850 question‑category pairs is split 70/15/15 for training, evaluation, and testing. Baseline prompting of the un‑fine‑tuned 0.6B model achieved only ~10 % accuracy on a 131‑case integration test, over‑using broad labels and sometimes producing out‑of‑list categories. Fine‑tuning with Unsloth + QLoRA using the full category names raised accuracy to ~79 %. A second fine‑tune altered the prompt to request fixed two‑letter opaque codes for each category, eliminating semantic overlap; this yielded ~92 % accuracy (120/131 correct). Remaining errors cluster around water‑related categories (water heater vs. pool) and suggest further data refinement. The model now reliably tags questions for downstream RAG retrieval.

Multiplication on modern 64‑bit CPUs costs ≈3‑5 cycles; 32‑bit and 64‑bit latencies are similar except on some E‑cores. Division remains expensive: 64‑bit integer divide ≈15‑96 cycles (e.g., Skylake‑X 37‑96, Zen 2 8‑41, Cortex‑A78 5‑20). Integer non‑multiply/divide ops usually finish in 1‑2 cycles regardless of operand size. RTTI dynamic_cast can be up to 5 × slower than a virtual call, though it adds no per‑object memory overhead. C++ exceptions incur ~2 cycles extra on the fast path, but when thrown cost 2.7 k‑5 k cycles; they become advantageous only when exceptions are rarer than ≈1 per 10 k‑100 k successful calls. Atomic compare‑and‑swap ≈15 cycles on a single socket, rising to 300‑600 cycles across NUMA sockets; they also limit ILP and bandwidth. Function calls cost ≈15‑30 cycles; indirect calls 20‑50 cycles; virtual calls 30‑60 cycles. Inlining eliminates call overhead and enables further optimizations (e.g., common sub‑expression elimination). thread_local accesses add 1‑3 extra indirections, varying by compiler. Thread context switches cost 2 k cycles directly, but cache‑miss penalties can add up to 1 M‑3 M cycles, making them “damn expensive.”