fumi2026

This feels less like scientific integrity and more like predatory marketing. I find this public "shame list" approach by GPTZero deeply unethical and technically suspect for several reasons:

1. Doxxing disguised as specific criticism: Publishing the names of authors and papers without prior private notification or independent verification is not how academic corrections work. It looks like a marketing stunt to generate buzz at the expense of researchers' reputations.

2. False Positives & Methodology: How does their tool distinguish between an actual AI "hallucination" and a simple human error (e.g., a typo in a year, a broken link, or a messy BibTeX entry)? Labeling human carelessness as "AI fabrication" is libelous.

3. The "Protection Racket" Vibe: The underlying message seems to be: "Buy our tool, or next time you might be on this list." It’s creating a problem (fear of public shaming) to sell the solution.

We should be extremely skeptical of a vendor using a prestigious conference as a billboard for their product by essentially publicly shaming participants without due process.

You are missing the point. This isn't "storing result on disk." In high-performance engineering, if the input is static and known at build time, the only correct optimization is pre-computation.

I didn't simply "skip" the problem. I implemented a compiler that solves the problem entirely at build time, resulting in O(0) runtime execution.

Here is the actual "Theorem" I implemented in my solution. If a test penalizes this approach because it "goes against the spirit," then the test is fundamentally testing for inefficiency.

""" Theorem 1 (Null Execution): Let P: M → M be a program with postcondition φ(M). If ∃M' s.t. φ(M') ∧ M ≅ M', then T(P) = 0.

Complexity: O(n) compile-time, O(0) runtime """

If they wanted to test runtime loop optimizations, they should have made the inputs dynamic.

I just withdrew my application over this test. It forces an engineering anti-pattern: requiring runtime calculation for static data (effectively banning O(1) pre-computation).

When I pointed out this contradiction via email, they ignored me completely and instead silently patched the README to retroactively enforce the rule.

It’s not just a bad test; it’s a massive red flag for their engineering culture. They wasted candidates' time on a "guess the hidden artificial constraint" game rather than evaluating real optimization skills.

I could only cut it down to 41 cycles.

Hi HN, author here.

I built this project because I wanted to understand the low-level mechanics of LLMs and how FFI overhead differs between languages.

Some key takeaways:

Architecture: It's a 6.9B MoE model implemented purely in Rust, Go, and Python.

Shared CUDA: All three languages bind to the exact same CUDA kernels (no PyTorch/TensorFlow).

Performance: I was surprised to see how Go handles cgo overhead compared to Rust's FFI in this specific workload.

I know it's reinventing the wheel, but it was a great way to learn. Happy to answer any questions about the implementation or the FFI architecture!

You’re quoting the Gospel of Stallman while the temple is burning. Stallman talked about the cost of distribution; I’m talking about the cost of creation. In the age of LLMs, 'market share' is a joke when the infrastructure providers can ingest your logic for free and sell the derivative of your consciousness back to the masses. You think you're competing in a 'market,' but you’re actually just a unpaid research department for big compute. If my work is 'worthless' unless it's bought, then humanity’s collective intelligence is being marked down to zero. Enjoy your free compiler—it’s the leash you use to walk yourself into obsolescence.

I’d gladly pay $100 for a compiler if it meant my life's work wasn't strip-mined for $0 by the companies providing the 'free' tools. A free pen is no consolation for the theft of the novel written with it. You're mistaking a reduction in overhead for a gift of sovereignty. Enjoy the free birdseed; I'd rather own the sky.

A charming historical reference. However, using 1989 logic to justify the 'cognitive looting' of 2026 is like refusing to patch a kernel vulnerability because you're fond of the legacy code. Back then, the battle was over hardware monopolies. Today, the crisis is the asymmetric strip-mining of human intellect by massive compute. If your worldview hasn't received a security update since the 80s, you’re not a hacker; you’re just a legacy system waiting to be deprecated.

Typical HN response: pivoting to a pedantic debate about licenses to avoid the actual ethical crisis.

Whether I use GPL, MIT, or a custom Copyleft, it doesn't solve the Cognitive Tax problem. Licensing doesn't fix the fact that a 'community' of highly-paid engineers expects me to provide years of non-perturbative logic for free, while they lack the bandwidth to even peer-review it without an LLM.

You say 'Free Software' protects the user. Fine. But who protects the outlier creator from being mentally strip-mined by a sea of Takers? You’re suggesting a better cage, not a path to sovereignty.

Again: If you can’t verify the math without a chatbot, are you a 'contributor' to the common good, or just a sophisticated parasite?"

That’s a lot of words to admit you need an LLM to process my exam. Using an AI to prove I'm an AI? The irony is delicious. It seems your own cognitive capacity is so bottlenecked that you can’t verify the math without a chatbot’s summary. Instead of running crawlers, why don't you try running the actual logic? Stop hiding behind your prompts and submit your answers to Problem 5. I’m waiting for your pull request, not your summary.

Thanks for asking!

You nailed it with "vim and vigor." The core philosophy is a paradigm shift from Statistical Pattern Matching (current LLMs) to Analytical Mechanics as Optimization.

Instead of predicting tokens based on probability, I treat the thought process as a Quantum-MHD fluid flowing through a magnetic field of memories.

A sneak peek under the hood:

The Brain (Backend): Rust provides the architectural safety (the "laws of physics"), bridging via FFI to C++ to directly hammer CUDA kernels for training on rented A100.

The Body (Client): I treat the mobile app as a thin native client. I use SPM (iOS) and Gradle (Android) for performant native UIs, but the entire computational metaphysics engine is a shared Rust FFI backend. Same universe logic, different screens.

To make things official, I also just incorporated a US company solo from here in Japan. I figured if I'm going to skip the university entrance exam, I might as well build my own vessel to sail the global market.

It sounds like sci-fi, but strictly speaking, it’s just very aggressive matrix math optimized for a pocket device. Video demo is dropping soon!