News for hackers. Stuff that matters.

krish678

I’m excited to share my latest research on the Dynamic Hierarchical Cooperative Swarm (DHCS) algorithm, recently published on SSRN: https://papers.ssrn.com/sol3/Delivery.cfm/7e20cab6-09bf-4fb2...

DHCS is a bio-inspired metaheuristic designed for high-dimensional and complex optimization problems, addressing limitations of conventional approaches like PSO or Genetic Algorithms.

Key features:

Dynamic clustering & adaptive roles: Each agent autonomously decides its behavior while maintaining swarm coherence.

Periodic synchronization: Ensures global coordination without sacrificing exploration.

Scalability: Tested on a 5000-dimensional Ackley function with superior convergence and robustness.

Efficiency: Reduces computational overhead while outperforming standard methods.

Versatility: Applicable to engineering design, supply chain optimization, ML hyperparameter tuning, and financial modeling.

This paper not only formalizes the DHCS framework but also presents a comprehensive experimental evaluation demonstrating its effectiveness in high-dimensional and dynamic environments.

I’d love feedback from the community, especially from those working in metaheuristics, swarm intelligence, and large-scale optimization problems.

Re:Exploring sub-50ns NIC receive paths via userspace MMIO on Tuesday December 16, 2025 @03:30AM (#46286137)
Hi HN,

I’ve been experimenting with how far NIC receive latency can be pushed on commodity hardware when you bypass the kernel and treat the NIC as memory-mapped hardware instead of a network device.

This is a research / measurement project, not a complete networking stack.

What I’m measuring: • ~20–50ns NIC RX → userspace visibility (device-dependent) • Busy-polling descriptor rings via MMIO • Zero-copy DMA buffers • No syscalls, interrupts, or kernel networking

Public repo: https://github.com/krish567366/BareMetalNIC

Docs / notes: https://baremetalnic.krishnabajpai.me

Important clarification: The public code focuses on instrumentation, register access, and timing methodology. Some experimental logic and tuning paths are intentionally not published yet.

This is mainly about how to measure and reason about latency accurately at this scale, not claiming a drop-in replacement for DPDK or kernel stacks.

Questions I’d genuinely like feedback on: 1. Where do you usually see the first sources of jitter below ~100ns? 2. On ARM64, how much penalty do you typically expect from memory ordering? 3. Any recommended techniques for validating RX timestamps externally?

Happy to clarify methodology or measurements.

Clarifying, since this is a fair concern:

The full C++ execution core is intentionally not published yet. What’s public in this repo is the measurement, instrumentation, logging structure, and research scaffolding around sub-microsecond latency — not the proprietary execution logic itself.

I should have stated that more explicitly up front.

The goal of the public material is to show how latency is measured, verified, and replayed, rather than to ship a complete trading engine. I’m happy to discuss methodology or share deeper details privately with interested engineers.

Appreciate the pushback — it’s valid.

Clarifying, since this is a fair concern:

The full C++ execution core is intentionally not published yet. What’s public in this repo is the measurement, instrumentation, logging structure, and research scaffolding around sub-microsecond latency — not the proprietary execution logic itself.

I should have stated that more explicitly up front.

The goal of the public material is to show how latency is measured, verified, and replayed, rather than to ship a complete trading engine. I’m happy to discuss methodology or share deeper details privately with interested engineers.

Appreciate the pushback — it’s valid.

For what it’s worth, I care more about whether the claims can be independently verified than how the explanation is phrased. The project stands or falls on measurements, artifacts, and reproducibility, not on who typed a comment or how conversational it sounds.

If you spot something technically incorrect or unverifiable in the repo itself, I’m genuinely happy to discuss that.

Thanks for checking this out! The “marketing-style” log was intentionally illustrative — showing the before vs. after of institutional-grade logging. The real framework uses multi-layer hardware/software timestamps, cryptographic manifests, and offline verification to produce fully auditable latency measurements. The snippet you linked is just the “before” example; everything in use follows the “after” model. That, was from intial times.

Show HN: Sub-microsecond (890 ns) trading execution research system

https://submicro.krishnabajpai.me/

I am sharing a research-grade, open-source trading execution framework that achieves a median end-to-end decision latency of 890 nanoseconds on commodity hardware.The project is designed for education, systems research, and latency instrumentation, not for live trading. It focuses on understanding exactly where every nanosecond goes in a trading execution path.Key features:- Kernel-bypass...

( Read More... | 9 comments | 5 points | on HN )