Hacker News Reader

> Go

Nowadays there are only two justifiable public languages you should be using for anything a) C++ b) Rust

Rust itself is dubious due to abysmal compile times and the fact that the only guarantees it gives you are of security (aka a skill issue). Modern LLMs write C++ that is as safe if not safer than Rust. Any other language choice is objectively wrong.

* For those inquisitive enough the keyword "public" is doing all the heavy lifting here. Pretty much everyone should be developing and using an in-house DSL at this point.

rfgplkon Meta and Microsoft take steps to reduce employee usage of Claude AI

So they're going to fall even further behind? Buying puts on Meta and Microsoft, or even better might give it to Fable to handle it for me

rfgplkon GPT‑6 and Intelligent UI for everyone

Mate this is like half a prompt of GPT-6

rfgplkon Shipping JPEG XL in Chrome

Yep.

rfgplkon AI-assisted proof of optimal packing for 11 squares

Isn't this obvious? Why do you need a proof for it, just stack the cubes next to each other? If we're talking infinitesimally thin squares, then stack them on top of each other? Am I missing something?

rfgplkon Halo: Combat Evolved (For Original Xbox) Ported to Windows, Linux and Android

The era of closed source software is over.

In case anyone wants to know Paradox (EU5/CK3/Vic3/Hoi4) ships half their Linux gsg binaries with full debug/DWARF 5 info + source map/locations. Reverse engineering the engine is trivial (all their games run the same engine just with a different backend). See the 1.4G victoria3 binary with over 700MB (!) of .debug_info.

0x00011096: DW_TAG_subprogram DW_AT_linkage_name ("_ZN9CPdxArrayIN17CPdxResourceCacheI14CGfxShaderFile17SVfsFullPathIndex9CPdxMutex8SPdxHashIS2_vESt8equal_toIS2_EE12SHashBlockerEiE5eraseEPKS9_SC_") DW_AT_name ("erase") DW_AT_decl_file ("/mnt/gsg/caligula/caligula/cw/clausewitz/pdx_core/container/pdx_array.h") DW_AT_decl_line (711) DW_AT_type (0x00011038 "CPdxArray<CPdxResourceCache<CGfxShaderFile, SVfsFullPathIndex, CPdxMutex, SPdxHash<SVfsFullPathIndex, void>, std::equal_to<SVfsFullPathIndex> >::SHashBlocker, int>::iterator") DW_AT_declaration (true) DW_AT_external (true) DW_AT_accessibility (DW_ACCESS_public)

0x000110a3: DW_TAG_formal_parameter DW_AT_type (0x0001138a "CPdxArray<CPdxResourceCache<CGfxShaderFile, SVfsFullPathIndex, CPdxMutex, SPdxHash<SVfsFullPathIndex, void>, std::equal_to<SVfsFullPathIndex> >::SHashBlocker, int> *") DW_AT_artificial (true)

0x000110a8: DW_TAG_formal_parameter DW_AT_type (0x0001104d "CPdxArray<CPdxResourceCache<CGfxShaderFile, SVfsFullPathIndex, CPdxMutex, SPdxHash<SVfsFullPathIndex, void>, std::equal_to<SVfsFullPathIndex> >::SHashBlocker, int>::const_iterator")

I'd do it myself but I've been burning tokens like a madman. If anyone has any free time, try it, so we can develop proper mods and optimize their engines.

rfgplkon Shipping JPEG XL in Chrome

Fun fact, I needed JPEG XL support for my C++ pipeline and I didn't feel like including any official libraries. Roughly $500 tokens later I had a fully working optimized JPEG XL spec compliant en/de/coder that outperformed the official codepaths (both cpp and rust) by 70% (lower runtime). Took literally 5 hours to build out. Can someone tell me what Google is doing?

rfgplkon PS5 Jailbreaks Are Escalating at an Unprecedented Pace

No need to jailbreak it when Claude can rewrite the whole stack in a matter of days.

rfgplkon Clean room implementation of Adobe products

We're one major LLM release away from being able to spit out _the whole adobe suit_ in a single prompt, while being safer, faster, and more featureful. I wonder at what point will tech companies stop interrogating candidates on useless Leetcode problems.

rfgplkon Sharing AI progress in mathematics

Nope, it's about to be turboboosted if anything. I myself have already formulated countless proofs (AI assisted naturally) in the last few months, despite: a) not having access to any academic resources b) not being involved in any academic circles. This research is now being employed in my startup, delivering ground shattering results. I actually ran analysis a few weeks ago seeing how much real world capital I would have needed to cough up to fund my efforts so far and it's literally in the _billions_. With less than a $100k in tokens I have been able to effectively generate the value of Apple or Microsoft in the early 2000s. This is only the beginning. Wait until you start seeing single person NVIDIA startups popping up.

rfgplkon Clean room implementation of Adobe products

This was the result of a _single_ prompt. Which actually shows the power of modern LLMs. I already have a from scratch C++ implementation of Photoshop, in my own custom UI toolkit, with my own custom GPU shaders. From scratch. Whole thing, ported over and I started last night. In preliminary benches it's roughly ~20-40% faster than their Photoshop rewrite. Will start heavy optimization passes and see how hard I can push it.

rfgplkon Sharing AI progress in mathematics

Frankly, I believe PhDs don't have to be novel in the absolute sense, only new research to the student. I can't remember how many times I've effectively invented something from a clean room approach only to realize someone already published something years ago or that my "new" algorithm has a name. So this really shouldn't be holding anyone back.

rfgplkon Clean room implementation of Adobe products

Is there any interest in a C++ rewrite of Adobe products? A pure Rust implementation essentially holds back portability and control massively, while C++ allows you to control and account for every single bit of memory.

rfgplkon Vibecoding isn't as fun as writing code by hand

99% of most projects is boilerplate. For instance let's say I'm making a video game and I want to add multiplayer. Well, most of the networking code is going to deal with deciding what protocol I will be using (UDP likely) what the packets are going to look like (basically just pushing simple data frames over the wire) and then messing around with writing a UDP reactor (probably epoll backed) to actually get my game to run. This _essentially_ is pointless boilerplate, because you need to mess around with looking up kernel intricacies, how you're supposed to wrangle UDP packets, what the kernel expects what some pointless spec written 50 years ago says (oh no if a UDP packet arrives while the other end has closed connection according to RFC whatever you MUST(!!!!) stop reading otherwise UB occurs). If you want to ignore all this now you need to find some library, hoping it work (it won't) and trying to wrestle it to work in your engine. I do _not_ care about any of this. What I do care about is how my multiplayer game is going to run, how players are going to interact with each other etc. LLMs allow you to focus on that.

rfgplkon Vibecoding isn't as fun as writing code by hand

There is a huge skill gap arising in using LLMs. You have some people (like me) who are able to direct LLMs and get them to produce (nearly) perfect code, while there's others who can't even get them to make a CRUD website without exploding.

rfgplkon Vibecoding isn't as fun as writing code by hand

Yep. Now you get to focus on actually solving the problems at hand rather than messing around typing thousands of loc of irrelevant boilerplate to get something to work.

rfgplkon Vibecoding isn't as fun as writing code by hand

Wrong. What you call "vibecoding" is in fact metaprogramming, or essentially the art of writing programs that write programs. Yes, the medium of exchange is common text (or ideas in their purest forms) which may seem different from traditional programming but is no different from typing in Rust or C++ syntax. The reason a large chunk of HN purists _detest_ it is due to them not being able to gatekeep development anymore behind obscure syntax rules or forcing developers to memorize irrelevant programming constructs. And before I get called out, I've effectively memorized the entire C++ standard going back however many revisions, and yes, I can confirm that it's a complete waste of time. LLMs (today, in their current forms) can understand and emit code far better than _any_ human developer. Amortized for time? It's not even close. With half of the tools I've built I've stopped counting my code generation in locs and switched over to KB of code per day. Far more informative at this point.

rfgplkon AI is now capable of developing its own inference hardware

Yep, 99.9% of people are completely oblivious to what LLMs can do. Just wait until the next gen of CPUs/GPUs designed by LLMs start coming out (fyi chip development tools have advanced centuries in the last few months) and you'll start seeing exponential gains in hardware.

rfgplkon JetBrains reported a net financial loss first time in its tracked history

Yep. Especially considering their primary userbase are technically apt developers, there's zero reason to use any of their products. Especially given how quickly the landscape is changing.

rfgplkon JetBrains reports revenue growth, net financial loss for 2025

https://or.justice.cz/ias/ui/rejstrik-$firma?p%3A%3Asubmit=x...

then Sbirka listin and download the filings. It's all in Czech so put it through GPT for translation

Summary:

JetBrains s.r.o. went negative because a large foreign-exchange loss overwhelmed a much smaller operating profit. The report explicitly identifies CZK 1.516 billion of currency losses caused by the Czech koruna strengthening against major foreign currencies. But “it was just accounting” would be incomplete: operating profit also fell 63.2%. These accounts use Czech accounting rules, not IFRS.

So two separate things happened: operations deteriorated by CZK 1.291 billion, and the financial result deteriorated by CZK 2.016 billion. Lower taxes cushioned the fall rather than causing it. Approximately 61% of the deterioration before tax came from the financial section and 39% from operations.

For cash generation, the reported operating cash flow is positive—but requires caution. It increased from CZK 5.059 billion to CZK 6.353 billion. However, the 2025 statement includes CZK 6.672 billion of positive net working-capital adjustments, while its before-working-capital subtotal is negative CZK 60.926 million. The positive final figure therefore should not be read as CZK 6.353 billion of recurring cash earnings.

Removing only that disclosed currency loss would produce CZK 1,191.121 million of profit before tax. That is a mechanical sensitivity calculation—not an IFRS profit figure or a fully currency-neutral result. It leaves derivative gains and all other reported amounts unchanged, and it should not be treated as adjusted after-tax profit. The report says the 2025 “other financial income” line consists mainly of derivative income.

rfgplkon JetBrains reported a net financial loss first time in its tracked history

They could establish a foothold in AI accelerated development but they sadly aren't doing it, instead focusing on "developing agents" (aka openclaw/pi/codex/claude simulacrum #9998).

rfgplkon JetBrains reports revenue growth, net financial loss for 2025

The metric itself is in millions, so the value is 16 billion CZK ~= 738 million USD

rfgplkon JetBrains reported a net financial loss first time in its tracked history

No disrespect meant, but I don't see how companies like JetBrains can survive (and I've read their financial statements, their revenue growth is still decent). All their revenue comes from products and services that are effectively a long-form agentic session, proven by how many OSS replicas of their stack is out there. Their Junie agent (itself a replica of all other agents on the market) can ITSELF be replicated in a few dozen prompts, as evidenced by the 1000+ GitHub agent repos out there, most of whom are operated by a single college student. What's worse is that JetBrains' primary customer base is supposed to be composed of technical users and developers, the exact cohort that should be skilled enough to use LLMs to replicate their services for effectively zero cost. I guess the only thing that's saving them is inertia and goodwill.

rfgplkon Why Common Lisp is now the best programming language

Yep. Or at least broadly the family of S-exp based languages. I've developed a (still closed source) Lisp dialect that has grown to what I believe to be the most(?) expressive and powerful programming language available today. As in, there is zero reason to ever pull out C/C++/Rust. It's fully compiled, with a system Fω typesystem, inductive types, and most importantly as of recently full whole program reflection. As in Lisps macro system extended to the further possible development. You can, quite literally in the language itself, define full compiler passes, manipulate the SSA, add/remove/analyze nodes.

   (module reflection_symbolic)

   (comptime
     (fn sx-kind (x k) (sym= (syntax-kind x) k))
     (fn sx-zero (x) (equal x '0.0))
     (fn sx-one (x) (equal x '1.0))
     (fn sx-add (a b)
       (cond ((sx-zero a) b) ((sx-zero b) a) (otherwise `(f+ ,a ,b))))
     (fn sx-neg (a) (if (sx-zero a) a `(fneg ,a)))
     (fn sx-sub (a b)
       (cond ((sx-zero b) a) ((equal a b) (syntax 0.0)) (otherwise `(f- ,a ,b))))
     (fn sx-mul (a b)
       (cond ((or (sx-zero a) (sx-zero b)) (syntax 0.0))
             ((sx-one a) b) ((sx-one b) a) (otherwise `(f* ,a ,b))))
     (fn sx-div (a b)
       (cond ((sx-zero a) (syntax 0.0)) ((sx-one b) a) (otherwise `(f/ ,a ,b))))
     (fn sx-id (a b)
       (if (and (syntax-binding a) (syntax-binding b))
         (= (syntax-binding a) (syntax-binding b)) (sym= a b)))
     (fn sx-lookup (x names vals)
       (if (= (len names) 0) x
         (if (sx-id x (head names)) (head vals) (sx-lookup x (tail names) (tail vals)))))
     (fn sx-map (xs names vals depth)
       (if (= (len xs) 0) (list)
         (const (sx-expand (head xs) names vals depth) (sx-map (tail xs) names vals depth))))
     (fn sx-expand (e names vals depth)
       (if (> depth 32) (syntax-error "symbolic expansion exceeds 32 nested helper calls" e)
         (cond
           ((sx-kind e 'symbol) (sx-lookup e names vals))
           ((not (sx-kind e 'list)) e)
           (otherwise
             (let ((xs (syntax-children e)))
               (let ((op (head xs)))
                 (cond
                   ((or (sym= op 'let) (sym= op 'let*))
                     (let ((ns names) (vs vals) (bs (syntax-children (nth xs 1))))
                       (declare (mutable ns vs))
                       (dotimes (i (len bs))
                         (let ((b (syntax-children (nth bs i))))
                           (let ((v (sx-expand (nth b 1) (if (sym= op 'let*) ns names)
                                             (if (sym= op 'let*) vs vals) depth)))
                             (set ns (const (head b) ns)) (set vs (const v vs)))))
                       (if (/= (len xs) 3) (syntax-error "symbolic let requires one pure body expression" e)
                         (sx-expand (nth xs 2) ns vs depth))))
                   ((sym= op 'the) (sx-expand (nth xs 2) names vals depth))
                   ((or (sym= op 'f+) (sym= op 'f-) (sym= op 'f*) (sym= op 'f/)
                        (sym= op 'fneg) (sym= op 'fsin) (sym= op 'fcos) (sym= op 'fsqrt)
                        (sym= op 'tuple) (sym= op 'vec3))
                     `(,op ,@(sx-map (tail xs) names vals depth)))
                   (otherwise
                     (let ((f (fn-ref op)))
                       (if (/= (len (fn-params f)) (- (len xs) 1))
                         (syntax-error "symbolic helper call has wrong arity" e)
                         (sx-expand (fn-body f) (syntax-children (fn-params f))
                           (sx-map (tail xs) names vals depth) (+ depth 1))))))))))))
     (fn sx-diff (e x)
       (cond
         ((or (sx-kind e 'float) (sx-kind e 'integer)) (syntax 0.0))
         ((sx-kind e 'symbol) (if (sx-id e x) (syntax 1.0) (syntax 0.0)))
         ((sx-kind e 'list)
           (let ((cs (syntax-children e)))
             (let ((op (head cs)) (a (nth cs 1)))
               (let ((da (sx-diff a x)))
                 (cond
                   ((sym= op 'fneg) (sx-neg da))
                   ((sym= op 'fsin) (sx-mul `(fcos ,a) da))
                   ((sym= op 'fcos) (sx-neg (sx-mul `(fsin ,a) da)))
                   ((sym= op 'fsqrt) (sx-div da (sx-mul (syntax 2.0) `(fsqrt ,a))))
                   ((= (len cs) 3)
                     (let ((b (nth cs 2)))
                       (let ((db (sx-diff b x)))
                         (cond ((sym= op 'f+) (sx-add da db))
                               ((sym= op 'f-) (sx-sub da db))
                               ((sym= op 'f*) (sx-add (sx-mul da b) (sx-mul a db)))
                               ((sym= op 'f/) (sx-div (sx-sub (sx-mul da b) (sx-mul a db)) (sx-mul b b)))
                               (otherwise (syntax-error "cannot differentiate this operator" op))))))
                   (otherwise (syntax-error "cannot differentiate this expression" e)))))))
         (otherwise (syntax-error "cannot differentiate this syntax" e))))
     (fn sx-partial (f index)
       (let ((e (sx-expand (fn-body f) (list) (list) 0)))
         (fn-with f 'body (sx-diff e (nth (fn-params f) index))))))

   (macro derive-partial
     (syntax-rules ()
       ((_ result source index)
         (fnderive result source (transform (lambda (f) (sx-partial f index)))))))

rfgplkon Opus 5.5 agents discover two room-temperature magnetic semiconductor candidates

I've been dabbling with some of my own (tiny) models recently and it's actually shocking at what they can "learn" despite having _zero_ mention of it in it's training data.

rfgplkon Opus 5.5 agents discover two room-temperature magnetic semiconductor candidates

Frankly, there is no point in trying to "understand" what an LLM does. Their thought process is effectively undecipherable by humans (it's essentially information arising from information) so even such a "simple explanation" is almost certainly wrong. The agents might appear to have "used this method", but the actual method of computation is far beyond our grasp.

Why are people being so belligerent about this? I thought it's fairly obvious at this point that LLM reasoning is far beyond anyones understanding. Or does anyone have a refutation?

rfgplkon Opus 5.5 agents discover two room-temperature magnetic semiconductor candidates

Of course, "LLM solves quantum gravity and proves existence of God", "nah brah, that's easy brah any kid could have done this brah".

This is what you sound like. I also like how the goalposts keep moving on a daily basis, a year ago it was that LLMs can't even write a Hello World program without making an error, but now things like this are "so easy a minimum wage intern could do it."

rfgplkon Opus 5.5 agents discover two room-temperature magnetic semiconductor candidates

This gave me the idea to actually create a full (QED accurate) atomic simulation software. Essentially would allow you to play around with things like this. At a glance my workstation _probably_ has enough compute to handle it. At least to fully simulate at least a few dozen atoms and compounds.

rfgplkon Opus 5.5 agents discover two room-temperature magnetic semiconductor candidates

Current frontier LLMs empower effectively anyone with limitless knowledge. Historically, if I wanted to hire an engineer to, say, create something like this I would have needed a multi-million dollar budget. Now, anyone with $200 (or less) can achieve it.

rfgplkon Run Qwen 3.8 Flash Next (125B) on consumer hardware (RTX 4090) at 100T/s

My hourly (consulting) rate starts at ~1000 EUR/hr.

Contact me if the offer is genuine: david@meridional.xyz