Jane Street

A Look Inside Jane Street’s Internship Program 2026

A candidate from an aerospace and computer science background secured an internship at Jane Street by solving a puzzle and demonstrating a collaborative problem-solving approach during interviews. During the role, the intern built a tool for bond desks and optimized GPU memory management using autoencoders, with the resulting code now deployed in active training systems. The experience highlighted a firm culture that values learning from mistakes and adaptability, featuring mentorship in a commodities trading project and social connections through shared hobbies like the Irish fiddle.

8 Figures on a Design Doc

Jacob Baskin

Before launching its "Superstore" system, Jane Street authorized a small team to purchase 10 petabytes of storage appliances for approximately $80 million based solely on a design document. This rapid, high-stakes capital expenditure of eight figures, which starkly contrasts with the centralized allocation processes the decision-maker previously encountered at Google, highlights the firm's unique operational agility. The speaker describes this unprecedented scale of immediate spending as both impressive and nervously significant for an organization of its size.

Building a Data Warehouse From Scratch with Jacob Baskin

Jacob Baskin, Ron

Jacob Baskin's career spans mechanism design research at Brown, building real-time ad exchanges at Google, and attempting to digitize urban parking infrastructure. At Jane Street, he engineered the SuperStore distributed database to replace legacy monoliths and designed the auction-based resource allocation system for the massive Hive compute cluster. His current work focuses on refining these mechanisms by addressing utility gaps in bidding models and implementing scalable data distribution architectures to support large-scale machine learning and simulation tasks.

Making Trades in Microseconds and Nanoseconds

Dwarkesh Patel, Ron Minsky, Dan Pontecorvo

The event analyzes how trading systems segment operations across ultra-low, mid-range, and long-duration latency horizons to align decision complexity with hardware capabilities. It highlights the critical trade-off between intelligence and speed, demonstrating that sub-100-nanosecond regimes require FPGA-based simple logic while longer intervals support sophisticated models. The discussion concludes by outlining how competitive positioning relies on an ensemble approach that tailors decision-making processes to specific latency buckets.

The Network as a Program with Nate Foster

Nate Foster, Ron Minsky

Nate Foster, a professor at EPFL and visiting researcher at Jane Street, bridges programming languages and networking by advocating for treating networks as verifiable programs through formal methods and Domain Specific Languages like Netcat and P4. His work has evolved from foundational theories on bidirectional data conversion to practical industrial applications, including the Butane system which compiles high-level latency policies into safe, distributed BGP configurations to replace error-prone manual router management. Foster's approach combines algebraic analysis of routing semantics with a software engineering culture that prioritizes rigorous testing and visualization, enabling complex network modifications while challenging traditional end-to-end principles in favor of in-network computing for specialized workloads.

Jane Street on GPUs, Trading, and Hiring: A Conversation with Dwarkesh

Jane Street, Dwarkesh Patel, Ron Minsky, Dan Pontecorvo

Jane Street executes a multi-tiered trading strategy that balances nanosecond-scale FPGA execution with long-horizon AI models while transitioning to a disaggregated global network featuring a $6 billion compute partnership with CoreWeave. The firm prioritizes model architecture diversity and custom hardware, including ARM and NVIDIA infrastructures, to navigate high-noise financial data without relying on single foundation models. This approach is supported by a hiring strategy focused on scarcity-driven talent acquisition and a human-in-the-loop philosophy that maintains critical judgment during complex market anomalies.

Dwarkesh Goes Inside Jane Street's Latest AI Data Center

Dwarkesh, Ron Minsky, Daniel Pontecorvo, Mark Mirchandani

Jane Street transformed a Texas data center into a high-density liquid-cooled facility housing 4,032 GPUs to execute large language model training and custom trading architectures. The retrofit replaces legacy air-cooling with an 18°C fluid distribution system that manages 140 kW per cabinet while utilizing proprietary software to dynamically redistribute power and prevent breaker trips during peak loads. Engineering safeguards now focus on mitigating new liquid-cooling risks like biological growth and leaks, enabling sub-100-nanosecond latency required for modern algorithmic trading compared to the millisecond scales of its historical "Hive" cluster.

Production Engineering When Trading Billions of Dollars a Day

Mark Doss

Mark, a production engineer at Jane Street, outlines a high-stakes trading environment where even a 0.01% error rate can trigger insolvency, necessitating a monitoring strategy that rejects standard service level objectives in favor of code-level, event-based alerts. The firm employs a defense-in-depth approach using redundant, symptom-focused detection systems to catch catastrophic failures like fat-finger trades or stale market data before they cascade. By integrating deep domain knowledge into incident response and treating monitoring infrastructure as more critical than the trading systems themselves, Jane Street ensures that traders and engineers collaborate to resolve unique operational risks with extreme precision.

The Cost of Concurrency Coordination with Jon Gjengset

Jon Gjengset, John, Gabriel Kreiman

The presentation challenges the conventional view that mutexes are inherently slow, demonstrating instead that performance degradation in high-concurrency environments stems from CPU cache coherence overheads and MESI protocol costs rather than the lock mechanism itself. To address false sharing and serialization issues found in reader-writer locks, the speaker details the Left-Right data structure, a lock-free architecture that achieves linear scaling for read-heavy workloads by decoupling reader access from writer synchronization. Finally, the discussion emphasizes that optimal synchronization strategy depends on the specific read-to-write ratio and consistency requirements, urging developers to profile cache behavior and avoid blind optimization of lock primitives.

Why Testing Is Hard and How to Fix It with Will Wilson

Will Wilson, Ron Minsky

Antithesis CEO Will Wilson founded the company to solve the non-determinism and state-space explosion challenges that plague traditional testing in complex distributed systems. The platform utilizes hypervisor-level emulation to create deterministic simulations of unmodified software, enabling exhaustive state-space exploration without the need for extensive manual test definitions. This approach has attracted major institutional users like Jane Street, which serves as both a customer and a Series A investor to validate the tool's efficacy in finding critical concurrency bugs and accelerating AI-driven development cycles.

Bryan Cantrill: Andreessen’s Folly - The False Dichotomy of Software and Hardware

Bryan Cantrill, Andreessen, Alan Kay, Jonathan Gruber, Trevor Johnsen, Tred Wansell, Jermaine

Speaker critiques Marc Andreessen's "Software Eating the World" thesis as a false dichotomy while detailing Oxide Computer Company's hardware-software co-design strategy to reclaim stack control. By abandoning proprietary layers like UEFI and Baseboard Management Controllers in favor of custom operating systems and holistic integration with AMD silicon, the company addresses systemic reliability failures that plague commoditized reference designs. This approach has already resolved complex hardware-software interaction bugs and positions the firm to pursue open-source firmware and transparent accelerator partnerships to eliminate vendor lock-in in future data center infrastructure.

Matt Godbolt: Advanced Skylake Deep Dive

Matt Godbolt, Jesper

Matt Godbolt, a prominent C++ developer transitioning to HRT, presents a detailed reverse-engineered analysis of the Skylake-era CPU microarchitecture based on community findings rather than official documentation. The talk dissects critical pipeline stages including the front-end's instruction decoding, the micro-op cache limitations, and the complex register renaming mechanics that define the processor's performance characteristics. Key revelations include specific hardware flaws like the Loop Stream Detector bug, port allocation strategies, and the diminishing returns of increasing architectural register counts compared to the hundreds of physical registers already available.

Arjun Guha: How Language Models Model Programming Languages & How Programmers Model Language Models

Arjun Guha

Arjun Guha presents a comprehensive analysis of large language models in programming, highlighting how traditional benchmarks are saturating while new methods like multi-PLE and language-agnostic transforms reveal significant performance gaps in low-resource languages such as OCaml. Through mechanistic interpretability techniques like activation steering, the talk demonstrates that internal model vectors can effectively correct type prediction errors and switch target languages without retraining, exposing shared representations across diverse syntaxes. These technical insights are contextualized by human studies showing that student success in prompting models hinges on providing specific semantic clues rather than syntactic fixes, while industry data reveals a surge in AI co-authorship alongside complex debates regarding actual productivity gains.

Making GPUs Actually Fast: A Deep Dive into Training Performance

Corwin, Savant Diaz, Sylvain De Wecker

Jane Street engineers optimize deep learning infrastructure by eliminating CPU-GPU synchronization bottlenecks and fusing PyTorch operations via `torch.compile` and Triton to maximize throughput. When automated compilation fails on complex Python logic, they deploy custom CUDA kernels that leverage shared memory and warp-level reductions to achieve nearly 1,000x speedups in specialized tensor operations. This hierarchical approach, ranging from standard PyTorch to hand-optimized C++, ensures efficient utilization of the H100's 132 Streaming Multiprocessors and strict memory bandwidth constraints.

Neil Mitchell: Pyrefly: Type Checking 1.8 Million Lines of Python Per Second

Neil Mitchell, Roman

Meta engineer Neil Mitchell introduced PyreFly, an open-source Python type checker reimplemented in Rust to address performance and scalability limitations for massive codebases like Instagram. The tool utilizes an aggressive memory eviction strategy and file-level concurrency to deliver rapid IDE feedback while supporting complex type features such as structural subtyping and flow narrowing. Released under the MIT license with over 100 contributors, PyreFly aims to replace legacy systems by prioritizing broad ecosystem adoption and seamless integration with build tools like Buck.