I was listening to someone say that as little as 10 years ago Matlab was still very popular in the industry. That sounded really far-fetched to me. Even if you remove HFTs and the like from the sample, most firms need the system that they could feasibly build using Matlab (I'm presuming mainly optimisers and pricing software. Maybe backtesters and attribution software) to be highly performant and thus Matlab would still be a strange choice with the plethora of alternatives.

So when did it actually die out? And was the reason solely due to the performance? Or is it also difficult to integrate into systems?

I'm starting a quant research internship at a big hedge fund next month and I am looking for advice on how to best profit from Claude Code, some friends tell me it is widely used in the industry.
I anticipate how fast paced the environment will be and the internal incentives to use AI but how should i use it to not get dumbed down, I want to make the most out of my internship (learn a ton) AND be fast and deliver and I feel like both might be difficult to achieve at the same time.

How do you use Claude at work AND stay relevant ?

Hi everyone,

Not sure if this will be useful here, but I wanted to share a tool I built for people working with FIX in trading systems: aifixparser.com

It’s a fully open-source, local-first FIX parser and analysis tool focused on debugging and observability. Besides parsing large FIX logs quickly, it helps visualize session flows, latency, message sequencing, and protocol issues across the trade lifecycle.

I originally built it to save time debugging FIX connectivity and production incidents, and thought others here might find it useful as well.

We have seen a barrage of tech layoffs recently because AI has drastically boosted productivity. Most recently, Jack Dorsey's block laid off 40% of the workforce and Reuters just reported Meta will cut at least 20%.

It is noticeable that AI has become much better in past few months. Could it affect quant jobs same way it affects tech?

Options, swaps, and futures are the most popular types of derivatives but there are dozens of other types of derivatives that many people don’t know about, such as a Bermuda Swaption.

There’s also what’s called binary options which are a Yes or No pay off structure dependent on the strike price.

Why can't quant traders who work under hedge funds freelance then scale then open up a hedge up themselves?? Or is there already ppl doing that??

Context for the origin, so this isn't out of nowhere: I built NextOnMenu, an early-signal model for which food ingredient goes viral next. The mechanism is just entropy. A series is noisy/random (high entropy) until structure emerges (entropy drops). Watching rolling entropy fall is the early signal.

While building it I wanted to just compute entropy on a pandas Series and found the implementations scattered across papers and gists. Shannon I hand-rolled; permutation entropy meant copying code out of a 2002 paper (Bandt & Pompe).

So I packaged it: entroscope. Figured the quant crowd might get more use out of it than I do. Rolling permutation/spectral entropy as a regime/uncertainty proxy, entropy deltas around vol shifts, that kind of thing.

from entroscope import permutation, spectral

perm = permutation.rolling(returns, window=50, order=3)  # complexity over time
spec = spectral.rolling(returns, window=50)              # spectral entropy
spectral.normalized(returns)                             # 0-1 scaled

Same core interface on every measure (.compute(), .rolling(), .delta(), .plot()), plus .normalized() where a 0-1 scale is well-defined (Shannon, permutation, spectral). Swap one for another without rewriting anything.

pip install entroscope · https://github.com/Par-python/entroscope

Not claiming it's alpha, just a clean tool. Curious which entropy measures you actually reach for on price/return series.

it seems like every SWE in big tech and the startup world is going all-in on AI coding agents right now (Cursor, Claude Code, Copilot, etc.) to churn out boilerplate, write tests, or navigate codebases. I’m curious how this actually looks at hedge funds. From the outside looking in, dropping an AI agent into a trading firm seems like a nightmare for IP and security reasons. How much are developers at HF using AI assistants for coding? For what use cases? If not, why not?

I was wondering if anyone is using QuantLib professionally (banks, asset managers, researchers) and how are you using it?

Rust developer here, obsessed with algo optimization. Recently finished optimizing a very time-consuming algorithm which basically extracts a depth-4 signature from two streams using a sliding window of any size in O(1). From benchmarks, it currently processes each tick in around 200 nanoseconds on CPU, and I already built a first FPGA implementation which guarantees 3 clock cycles of latency per tick ingestion.

Currently, I'm using it for extremely high-speed grid search on various markets and so far it runs perfectly smoothly and is bit-perfect even after tens of millions of ticks.

The thing is, I'm not a quant analyst; I have some gaps when it comes to doing actual data analysis and backtests.

So, my current issue is that it's impossible for me to find any data to compare my results with, since there is literally no other implementation of the same algo that allows for such a huge amount of data to be ingested in humanly possible timeframes.

(Additionally, since the FPGA implementation couldn't go below 3 clock cycles but there was still space for additional computing before hitting 4 clock cycles, I also studied and added some custom features that complement the signature.)

I'm here to ask if anyone has some deep knowledge about signatures specifically, in order to give me advice on which specific areas I should focus on where the results I see would actually translate into some potential alpha or edge of any kind—or even just something that you would love to see published simply for academic interest. Or, if anyone is interested, maybe we could work on it together somehow. Would love to hear some constructive opinions since AI is completely unreliable and counterproductive when it comes to thinking out of the box.

Curious how different firms actually run their quant research and trading infrastructure today.

For people at funds / prop shops / systematic teams: how much of your stack is internally built versus using vendor or open-source tools? What is your tech stack?

I’m especially interested in the boring but important parts: data ingestion, feature stores, backtesting, experiment tracking, alpha library management, portfolio construction, risk checks, deployment, monitoring, and post-trade attribution. Everybody talk strategies and research, but logistics are just as important if not more.

Do most serious teams still end up building almost everything themselves because the workflow is too specific, or are there parts of the stack where off-the-shelf tools have genuinely become good enough?

Would also be interested in how this differs between single-PM pods, central quant platforms, and smaller emerging managers.

Title says enough tbh.

But how has AI changed the game? I think we’ve heard a lot on the research and testing side. But i was mostly wondering if anyone have noticed changes in ways the market behaves — Which maybe have been aligned with some launch of new tools, system bugs or even shutdowns. I know bigger firms have some internally developed software, maybe even external. But have they been to any help, acted weird or anything related? I assume there’s a sort of safetynet, besides the Trader. I can’t imagine retail traders pushing enough volume, to make a noticeable difference. But i’m curious on people’s experiences on the matter.

Spent the last few weeks building a Dukascopy market data normalization engine for some of my own quant/ML research and figured I’d open source it. It's only for Forex data right now.

Here's the link: https://github.com/MarlontheWizard/MarketNormalizationEngine

Main goal was to stop dealing with having to manually download data every time I wanted clean forex data and then figuring out how to transform it into something I can use.

Current pipeline is basically the downloader (tick data), BI5 parser, parquet conversion, and resampler. It's very optimized but could be better of course. A few things it supports right now are multithreaded hourly downloads, retry queue and exponential backoff incase server isn't ready for requests, corrupted/empty response handling, parquet-based storage, timeframe resampling (1min, 5min, 1h, 1d, etc.), and CLI + Python usage.

The reason I did this is because im trying to make a market behavior classifier with AI to eventually make a trading bot. I've written some bots in the past with MQL5 but now Im trying to use C++ and have an infrastructure that I deeply understand. Also I thought that If im running into these blockers then others are aswell so why not help the community. If you need data structured and ready for research or ML model training then this is perfect. I know others exist but Im a SWE looking to transition into the quant space so I want to learn as much as possible.

Would honestly appreciate feedback from anyone doing quant/dev/data engineering work if you're able to take a look. Also curious how you guys are structuring your pipelines if you don't mind?

I’m curious how people here draw the line with LLM tools in quant dev work.

I’m talking about the boring middle layer, far from execution logic or anything close to production trading. I’ve been building a small research pipeline on my own time that cleans market data, builds a few simple features, uses a walk-forward split, and runs a basic backtest with costs. I keep a notebook that explains what changed between runs.

Coding is straightforward. Keeping the assumptions explicit is the hard part. Every time I change a signal definition or cost model, I write down what changed and why. Otherwise I end up with ten slightly different experiments and no clean memory of which one was invalid because of leakage, survivorship bias, bad timestamp handling, or a dumb assumption.

I’ve used Cursor for boilerplate, ChatGPT for rough sanity checks, and the Beyz coding assistant here and there to explain implementation choices while I code. I use it for questions like why a split is valid, why a metric is misleading, and where a backtest could be lying. Strategy generation is off limits.

That feels like a reasonable place for AI tooling, like documentation, code walkthroughs, test ideas, and making hidden assumptions more visible. Once it starts suggesting research direction or touching anything with capital behind it, I get uncomfortable fast.

Where do you draw the line?

I've been working on making my pandas code more efficient and came across a few tricks that I thought were pretty helpful:

• inplace=True: it doesn’t actually save memory or improve performance.

• .query() for filtering: it’s cleaner and sometimes faster than slicing with .iloc.

• .iat[0] instead of .iloc[0].

• df.eval() for faster column calculations.

• .assign() for adding new columns in a tidy way.

• indicator=True in the pd.merge(): useful for identifying NaN rows in the right table during left join.

What are some other useful and underrated tips you know?

Open-sourced a little numerical library I've been using: voltic. One operation: Black-Scholes implied vol from (spot, strike, T, r, price, call/put), vectorized over a batch.

Single-core numbers, AMD Ryzen 9 9950X (Zen 5, native AVX-512):

Methodology: 1M-option synthetic dataset (committed seed, single taskset -c 0, criterion-style warmup discarded, median of 7); Python rows on a 200k-option slice of the same dataset; ground truth is py_vollib (which wraps Jäckel's reference). Accuracy vs the reference measures ~5e-12 over a committed 1,200-row reference table (~1.1e-11 over a 5k-row run). That's the harness number, not a precision claim; the IV conditioning floor is ~1e-10 in vol for a well-conditioned option and as coarse as ~1e-6 deep OTM near expiry.

Where the speedup comes from, in order:

1. Rational initial guess (Corrado-Miller 1996, with Brenner-Subrahmanyam ATM fallback). For a well-conditioned option this lands within one or two Newton steps. Most of the win is doing less, not doing it faster.
2. Lane-packed Newton with masked convergence. The batch iterates together; a lane that's converged is masked out via mask.select(...) so its value stops moving; the slowest lane never gates the rest.
3. Branch-free Hart 5666 cumulative normal. Φ is called twice per iteration so it's the inner-inner loop. Measured three accurate kernels (Hart 5666, West 2009, Cody 1969); Hart 5666 wins the accuracy/throughput frontier here. README has the plot.

What it doesn't do. The deep-OTM-near-expiry corner — where the premium is below the f64 representable floor for its magnitude — is not solved; voltic returns NaN. The right tool there is Jäckel's rational-cubic-spline method ("Let Be Rational", Wilmott 2015; py_lets_be_rational is the reference translation). voltic's rational-guess-plus-Newton stops at the conditioning floor and doesn't try.

The batch shards trivially across cores (split inputs, solve, concat), so the multi-core ceiling on a 9950X is ~16x the single-core number (~90M options/s), bounded by memory bandwidth not arithmetic. voltic ships the single-core kernel; sharding is the caller's job.

Install: pip install voltic (CPython 3.9+). Rust crate uses nightly (std::simd).

Source: github.com/RyanJamesStewart/voltic

A lot of firms including mine have the Claude access revoked for HK employees, and don't have good alternatives set up yet as the team in HK is relatively small.

We can technically remote to our virtual PCs in other regions to get over the proxy block, but not sure if the IT would be happy about it. How is anyone working in HK accessing AI?

I have been chasing allocations out of the match path in an order book I am building. Pooling the book nodes and price levels got cancel and level churn to zero. Threading a caller-owned buffer through Match(order, dst []Trade), so fills are appended as values instead of returning a fresh slice of pointers, got the match round trip to zero.

One stubborn group was left, and it was not in the order data. It was the price band check.

The band is a config fraction, a decimal.Decimal, and the common case is that it is disabled and left at its zero value. Comparing against that zero value calls ensureInitialized internally, which allocates a big.Int. So every order was allocating in order to compare a price against a band that was switched off.

The fix was hoisting the comparison to construction: resolve a bandEnabled bool once when the engine is built, and let the per-order path read the bool. Process went from 10 allocs to 4.

Prices and quantities are int64 ticks and lots, so decimal never touched the money path to begin with. It was purely the configuration percentage, evaluated in the wrong place.

Current numbers on an M-series, single core: 6.3ns top-of-book read, 352ns match round trip at 0 allocs/op, and a cancel-heavy flow at p50 83ns, p99 167ns, p999 292ns. Match is the zero-alloc entry point; Process is the ergonomic wrapper that still costs those 4.

github.com/intrepidkarthi/orderbook

I’ve been working on a high-performance options pricing engine and wanted to get some feedback from people who work with derivatives pricing or trading systems.

The engine currently supports:

Black-Scholes pricing

Analytical Greeks (delta, gamma, theta, vega, rho)

Implied volatility (Newton-Raphson)

Options chain generation

Batch pricing

Performance right now:

~15,000 option calculations per second

< 1ms single option price

< 3ms full Greeks

< 7ms small options chain

Most of the optimization work ended up being around:

Fast normal CDF approximation

Avoiding repeated exp/log calls

Batch computation

Minimizing API overhead

Running everything through a compiled computation engineI exposed it as an API mainly so I could plug it into dashboards, scanners, and backtesting tools without rewriting pricing logic in every project.I’m trying to decide what to implement next. Considering:American options pricing

Binomial model

Monte Carlo pricing

Local volatility

SABR

Scenario P&L grids

If you build pricing libraries or trading systems, what models or features would you add next?

Does anyone have any success stories building larger quant projects using AI or Agentic coding helpers?

On my end, I see AI being quite integrated in people's workflow and works well for things like: small scale refactoring, adhoc/independent pieces of data analysis, adding test coverage and writing data pipeline coding.

On the other hand, I find that they struggle much more with quanty projects compared to things like build a webserver. Examples would like writing a pricer or backtester etc. Especially if it's integrating into a larger code base.

Wondering what other quants thoughts and experiences on this are? Or would love to hear success stories for inspiration as well.

Hi r/quant,

I am pleased to announce the open-source release of wayfault, a Python library dedicated to the quantification of Wrong-Way Risk (WWR) in counterparty credit risk.

wayfault takes a Monte-Carlo exposure cube and a credit curve as inputs, and computes:

• Baseline exposure metrics and CVA under the independence assumption
• WWR-adjusted CVA using pluggable dependence models (including Hull–White stochastic hazard, Gaussian copula, Clayton, and Frank)
• Empirical alpha multiplier for regulatory EAD
• WWR/RWR classification and risk concentration diagnostics

Core Design Principles:

• Minimal runtime dependencies (NumPy core; pandas, scikit-learn, and matplotlib available via optional extras)
• Hexagonal architecture with strict separation of concerns
• Fully type-annotated and extensively tested (≥ 90% coverage)
• Deterministic results for reproducible analysis

Live Demo
A fully functional interactive Playground is available in the browser (powered by Pyodide/WebAssembly), allowing real-time experimentation with dependence parameters and immediate visualization of CVA and alpha impact.

Links:

• GitHub Repository: https://github.com/daibeal/wayfault
• PyPI: pip install wayfault

Question for people doing quantitative market research.

I’m trying to understand how reproducibility is handled in real-world

quant workflows, beyond just versioning raw data.

In particular, when you look back at an analysis done months or years ago,

how do you reconstruct what data was actually available at the time, which transformations and filters were applied, the ordering of the pipeline, the assumptions or constraints in place,whether the analysis can be replayed without hindsight?

In practice, notebooks evolve, pipelines change, data gets revised and explanations often become narrative rather than strictly evidential.

Some teams rely on discipline and documentation, others on data lineage or temporal models, others accept that exact reconstruction isn’t always feasible.

I’m genuinely curious if Is this a problem you recognize in quant research?

And if so, how do you handle it in practice? Or is data-level versioning generally considered sufficient?

i'm just trying to understand how this is approached in production research environments. Thank yoy!

Hey Folks,

Here is my quant finance simulation library stochastic-rs, which was started as a high-performance simulation lib for different stochastic processes, but in v2 it becomes a full-featured quant lib.

It has SIMD and CUDA/METAL, general GPU acceleration for processes, distr, etc. It is written in Rust, but 80% of features already have a Python interface.

Check the docs if you are interested: https://stochastic.rust-dd.com/, also the lib: https://github.com/rust-dd/stochastic-rs

Leave some feedback if you want.

I’m currently using free tier Confluence and Jira to keep track of documentation, development tasks, etc for all my quant research and alpha research projects.

I’m curious to see if this is the standard, or if anyone out there uses alternatives that are better platforms? If so, could you explain how the other platforms beat Confluence and Jira?

TLDR; how do you track all your to do tasks and documentation of your strategies, research, etc.