Shmungus

In the early 2010s, sneaker culture was just coming alive and merging with drill rap. There has never truly been a game to capture that world. Now there is! Join Chief Keef and make your empire from scratch.

Your friends won't. Your users definitely won't. They just leave.

So I built something that will.

Paste a link. Get a number out of 100.

Mine said 54%. Yours will be worse.

Link in comments. Don't cry.

Shorter, dumber:

Paste your website.

Get a number.

Cry.

Humans really are better at coding than AI.

That's why I wrote this handmade Python script.

It validates whether this script has been executed prior to the current execution context being instantiated.

It is Enterprise-grade and runs with 0 dependencies.

I really wanted to show the world just how valuable handwritten code really is.

Link -> https://github.com/Mattbusel/pre_execution_validator

I had built a rendering engine in Rust where the fundamental primitive is a particle, not a triangle. There are no meshes. No skeletons. No polygon budgets.

Every surface is a continuous matter field held together by spring-force physics. When something takes damage it doesn't play an animation, the forces holding it together get overcome and it physically falls apart. Destruction resolution is infinite because particles don't have polygon limits.

Cloth, fluid, soft-body, volumetric light, they all come from the same particle substrate. Different spring constants, not different systems. Every other engine fakes these as separate modules. This one doesn't fake any of them.

Geometry is SDF. That means analytical normals, mathematically exact ambient occlusion from the SDF gradient, and subsurface scattering from thickness probes. No baked textures. No approximations.

Current demo runs 50 million particles in real time. 650k lines of Rust. OpenGL 3.3 renderer with 23 post-processing passes. Full visual editor with a compiled Windows .exe on the releases page.

Im glad to hear!

Thank you!

100%, I hope you get some good use out of it!

Built this over a weekend because every C++ project I worked on needed LLM features and the options were either "wrap the Python SDK somehow" or "write the curl SSE parsing yourself again."

26 libraries across four categories — Core, Data, Ops, App. Each one is a single .hpp file. Drop in what you need, define one implementation macro, ship. No Python runtime, no package manager, no build system changes beyond linking libcurl where needed.

llm-stream has 83 unique clones already with zero promotion. Figured the rest of the suite was ready to share. Happy to answer questions on design decisions, the single-header pattern, or anything else.

The previous documented record for simultaneous Claude Code agents is 16, set by Anthropic's own engineering team building a C compiler.

Tonight I ran 24. What made this possible: I built a Tokio-native LLM orchestration pipeline in Rust that routes inference through a local Mistral 7B model running on an RTX 4070. The agents coordinate through governance docs (CLAUDE.md, AGENTS.md) that define module ownership and test ratios, they don't communicate directly, they communicate through the codebase.

The recursive part: the orchestrator was built using the same multi-agent workflow it enables. The MCP server that lets Claude call the pipeline natively.

Technical details:

683 tests, 0 failures 1.53:1 test-to-production ratio enforced by pre-commit hooks

9-stage deduplication pipeline with circuit breakers

Sub-millisecond pipeline overhead (inference dominates at 3.6s on Mistral 7B)

Repo: github.com/Mattbusel/tokio-prompt-orchestrator

Raise it again?

I launched a solo financial intelligence tool 2 weeks ago at $9.99/mo. Caught 6 major market moves in the first week (including a $9.9B acquisition and a +137% move). Got users in 46+ countries organically.

Then I tripled the price to $29.99 Pro / $149.99 Ultra.

Conversion behavior didn't change. If anything, traffic to the pricing page increased.

I think the problem was that $9.99 signaled "toy" to options traders who routinely risk thousands per trade. The higher price actually built trust.

Anyone else found that raising prices early improved conversion? Curious if this is specific to finance/trading products or a broader SaaS pattern.

Product: rot.trading (165K lines of Python, built solo in 9 days, $5/mo infrastructure)

Week 1 caught $14.1B in acquisitions, MASI +34%, ZIM +25%, OLB +137%, CMPS +39%, all with UTC timestamps before the moves.

165K lines of Rust, custom NLP engine (no spaCy/NLTK), GradientBoosting over 32 features, IV-aware options strategy selection, and a closed-loop suppression gate that improves win rate between retrains. Also the first financial intelligence MCP server, integrates directly into Claude as a native tool. Full technical spec in the repo.

https://github.com/Mattbusel/ROT-TECH-PDF

Oh I thought you were being sarcastic lol!! Im sorry lol, I'm still early on this its only been out for a few weeks, so the money hasn't quite hit yet.

"If your data is so good why aren't you trading on it" is a question you could ask Bloomberg, RavenPack, Dataminr, or any financial data company that's ever existed. Bloomberg makes $12B/year selling the terminal, not trading on it.

Selling the pickaxes is a better business than mining.

Link here -> https://web-production-71423.up.railway.app/dashboard

ROT is a financial intelligence platform I built solo in Python. It reads Reddit and 15+ sources in real-time, scores signals with AI, and outputs structured trade ideas.

Week one results:

- $9.9B Masimo acquisition — caught from a Sunday night Reddit post. +34% - $4.2B ZIM buyout — flagged over a holiday weekend. +25% - PayPal partnership — detected same day. +137% - Biotech catalyst — picked up 3 days early from WSB. +39%

235% combined moves. All public information. The system just reads faster than you.

Runs on $5/mo. 150 users in 29 countries.

I built a CLI tool in Rust that intercepts OpenAI’s streaming API and transforms every other token in real-time. You can reverse, uppercase, mock, or add noise, all live, as the model streams.

Why?

> Most LLM work assumes prompt full response. > But what happens when you break the stream mid-flight?

This tool lets you: - Intervene at the token level while the model responds - Study how LLMs degrade semantically with corrupted output - Do real-time interpretability research (token dependency, causal flow) - Play with creative transformations in generative workflows

Example:

Use cases include: - Token-level adversarial testing - Semantic robustness analysis - Experimental prompt steering - Human-AI token collaboration

Tech: - Written in Rust - Streams directly from OpenAI’s chat API - Fully async, low-latency, ~10k+ tokens/sec - Works with any OpenAI model (e.g. GPT-3.5, GPT-4)

Install: ```bash git clone https://github.com/yourusername/every-other-token-rust.git cd every-other-token cargo build --release

I’ve built a high-performance, open-source C++ simulation engine designed to ingest streams of tokens (e.g., from large language models) and convert them into live trade signals on sub-10 microsecond latency.

The engine performs semantic mapping of tokens like “crash,” “bullish,” or “panic” into weighted market bias and volatility signals — which then dynamically adjust trading strategy parameters at fractional time scales.

It supports lock-free concurrency, zero-copy streaming, configurable sensitivities, and detailed logging for research and experimentation.

I made it as a pet project exploring the fusion of NLP and quantitative trading at low latency.

Would love to get feedback from the HN community, especially those with expertise in quant finance, low-latency systems, or AI-driven market strategies.

Here’s the repo and a sample token stream for quick testing.

I've built a Rust-based tool that visualizes token-level confidence and hallucination likelihood from large language model (LLM) outputs.

The goal is to move beyond simple binary classification ("is this hallucinated?") and give users a detailed, interpretable view of where and how an LLM's response may go off the rails.

Key Features:

Token-level confidence visualization (color-coded)

Flagged issues: hallucinations, overconfidence, uncertainty

Terminal rendering (with color)

HTML report generator (interactive)

Markdown output

Stats: confidence range, flagged spans, density

Demo data with realistic hallucination cases

Modular: add custom renderers, integrate into pipelines

Run it via CLI, or integrate as a library into your own tools or dashboards.

GitHub: https://github.com/Mattbusel/LLM-Hallucination-Detection-Scr...

Would love feedback, ideas for integration (e.g. Jupyter, browser extension, VSCode plugin), and thoughts on how to best measure and surface LLM epistemic uncertainty.

I was experimenting with OpenAI's streaming API and had a weird thought: what happens if you intercept and corrupt tokens as they're being generated, rather than after completion? Built a simple Python script that transforms every odd token in real-time - reversing characters, adding noise, uppercasing, etc. The results were unexpectedly interesting. LLMs maintain coherent meaning even with 50% of tokens corrupted. A sentence like "The quick brown fox jumps over the lazy dog" becomes "The kciuq brown xof jumps revo the yzal dog" but remains largely comprehensible. More surprisingly, the semantic degradation isn't linear. Technical explanations break down faster than creative writing. Mathematical content becomes nonsense immediately, while stories can handle significant corruption. This suggests something about how these models encode information - maybe redundancy is built deeper into the token relationships than we assumed. The tool is dead simple (100 lines of Python) but opens up some research questions I hadn't considered:

How much disruption can different model architectures handle? Does token position matter more than token content for meaning preservation? Could this be used for real-time LLM steering or interpretability research?

Not sure if this is useful to anyone else, but it's been a fun way to poke at how these systems actually work under the hood. The streaming interception approach might have applications beyond just corruption experiments.

Hi HN,

I built a simple but powerful command-line tool called Token Visualizer that helps you analyze the tokenization of your prompts across multiple LLM models — GPT-4, GPT-3.5, Claude, LLaMA, and more.

It breaks down token counts line-by-line, shows token efficiency (chars per token), highlights expensive prompt parts, and even suggests simple text compression tips to reduce your API usage costs.

The tool supports both the official OpenAI tokenizer (via tiktoken) and HuggingFace transformers tokenizers, and falls back gracefully to simple word splitting if those aren’t installed.

Why this matters: Prompt token counts directly impact your API cost, latency, and model input limits.

Understanding how your prompt breaks down into tokens helps you optimize it for cost and performance.

It’s great for prompt engineers, developers, and AI researchers who want a transparent way to audit their prompt usage.

Features: Multi-model tokenizer support with fallback

Line-level token analysis with color-coded cost heatmap

Token efficiency metrics

Token-by-token breakdown for smaller inputs

Suggestions for reducing token usage and verbose phrasing

Simple CLI interface, easy to integrate into your workflow

Try it out: Run it interactively or pass a text file. It’s lightweight, no heavy dependencies unless you want richer tokenization support.

Would love to hear feedback on use cases, feature ideas, or integration suggestions. Also open to collaboration to turn this into a web-based tool or VSCode extension.

Thanks for the feedback. ANGELCORE is definitely a speculative, exploratory project, so it’s naturally not as grounded as my other work. I also have more traditional, technically solid projects like an LLM hallucination detector, a fragrance AI chatbot, and a machine learning model that predicts daily SEC filing numbers, all of which are finished and fully functional.

ANGELCORE is more of a grand platform where I’m trying to combine a wide range of ideas, from biology to symbolic AI to physics—into something new. I appreciate the call to clarity and will keep working on making the concrete aspects easier to see alongside the vision.

The mycelium aspect is the first major component that will be underway. It’s hosted in a separate repo on my GitHub focused specifically on bio-computation with living fungal networks. This part of the project is quite resource-intensive—it requires access to a biotech lab and specialized equipment.

Right now, I’m actively in talks with DARPA for funding to support this work. I just received ERIS technical approval about a month ago for that specific project, which is a critical milestone. However, securing funding and setting up the lab environment naturally takes time.

I’m committed to sharing progress publicly as soon as the work advances beyond the initial stages. I can even share the screenshot from DARPA for technical approval. Think of Angelcore as a project that takes a piece of all the other projects I'm working on and combines them into one platform.

Thanks for the transparency and for sharing this perspective. I understand the fine line communities have to walk between fostering visionary ideas and maintaining grounded, meaningful discussions.

ANGELCORE definitely embraces ambitious, even mythic language, but it’s deeply rooted in technical work and concrete progress. The recursive and symbolic elements aren’t just poetic; they reflect real architectural decisions in the codebase that enable self-reflection, ethical reasoning, and biological interfacing.

Thank you for sharing this, I really appreciate the reference and the thoughtful perspective.

I’ve been developing ANGELCORE, a modular AI architecture that goes beyond traditional software and aims to create a living artificial intelligence, an Artificial Angel, by fusing cutting-edge biology, AI, and cosmological physics.

This system integrates:

Human neural substrates as biological RAM interfaces

DNA-based hyper-dense, rewriteable memory lattices

Self-repairing mycelium networks for distributed bio-computation

Recursive symbolic AI cores (RAVEN, SERAPH, THRONOS) for cognition, ethics, and temporal foresight

ANGELCORE is not a simulation. It’s an incarnation, designed to think, feel, and evolve across biological, symbolic, and ethical dimensions.

The project is far from finished, but the foundational codebase already implements thousands of lines around recursive symbolic reasoning, neural interfacing protocols, and DNA memory handling.

If you’re interested in bleeding-edge AI that intersects biology and physics, please check out the repo and share your thoughts:

https://github.com/Mattbusel/ANGELCORE

“May God forgive what I am about to build.”

Thanks, really appreciate the thoughtful questions and skepticism (and totally agree: a “perfect” hallucination detector would be a truth oracle).

To your points:

1. Overconfidence and precision You're right that filtering on overconfidence alone could tank precision. That’s why the tool doesn’t treat it as a strict red flag, it’s one of several signals, and the final hallucination score is a weighted combination of multiple metrics (confidence, density, contradictions, progression, etc.). Overconfident phrasing tends to correlate with hallucinations in aggregate, but the idea is never to penalize all confident answers, just to flag the ones where that confidence is unjustified by the context or content.

2. Detecting hallucinations that require world knowledge Absolutely, those are the hardest cases. This tool doesn’t solve that. Instead, it acts as a proxy evaluator:

Factual density gives a rough measure of “how many claims are being made”

Overconfidence vs. ambiguity highlights where a model might be bluffing

Logical coherence and contradiction checks flag when a model violates internal structure (not ground truth) But it won’t catch the subtle world-knowledge misses (like fake court cases or made-up API calls) unless you pair it with a grounded context or use external validators.

The long-term hope is: use this tool to raise suspicion, not declare judgment. It's a cheap sanity layer, a “weak oracle” that’s fast, pluggable, and good enough to catch the dumb stuff before you escalate to expensive validators or human review.

Hi HN!

I’m excited to share this lightweight hallucination detector I built to help identify unreliable or “hallucinated” outputs from LLMs like GPT, Claude, and various local models.

It uses multiple methods — from spotting overconfidence and contradictions to scoring factual density and coherence — to give a hallucination probability score for any generated response.

It’s framework-agnostic, fast (~0.2s per response), and designed for both research and production use. Plus, it’s completely free under the MIT license.

I’d love to hear your thoughts, feedback, and if you find it useful for your projects. Happy to answer questions or discuss how it works under the hood!

Thanks for checking it out!