Loading SMSS exhibit…
Loading SMSS exhibit…
首页/Exhibition Hall 01 — Stock Market Simulation System
Built by Zhu Yu and Zhao Sibo, Renmin University of China
A limit-order-book exchange engine decoupled from any particular trader model. The engine, the order protocol, the trader pool, and the monitoring dashboards each evolve independently — a new research question requires only a new model, not a new system.
The exchange natively implements the complete six-phase A-share trading day — opening call auction, indicative-price publication, continuous auction, midday break, closing call auction — directly applicable to research on price discovery and informed trading across market phases.

▶ LIVE · EXCHANGE MONITOR · processing the live order flow from one specific trader model — others can plug in
② Why Build From Scratch
Why this matters
Stock market research has moved from analytical tractability to computational fidelity. Static models and closed-form-equilibrium approaches impose simplifications that limit which questions can be asked. Three shifts make a different kind of platform necessary:
The combination — a faithful exchange engine that any trader population can connect to, observable in real time, generating tick-level data at any granularity — is what the research required.
Why nothing off-the-shelf worked
General-purpose agent-based modeling frameworks were considered. Each was designed for a different priority:
What none provided simultaneously: language-agnostic engine + standard order protocol + browser-anywhere monitoring + A-share native trading day + tick-level Parquet output + decoupled architecture supporting multiple concurrent trader populations.
What the platform offers — independent of any particular trader model
Researchers can build any trader model, customize any logical real-time market state feedback for the agents to observe, deploy on the same machine or across a cluster, and connect to the engine to generate tick-level data for analysis.
Exchange Engine
Price-time priority limit order book, A-share six-phase trading day, asynchronous Parquet persistence. 460K orders/sec single-thread peak; ~67K sustained with 10K-agent Main ABM at 15% engine utilization, leaving 85% headroom for richer experiments.
Standard Order Protocol
ZMQ + msgpack on TCP. Any trader process — algorithmic, reinforcement learning, behavioral, or human-in-the-loop via thin adapter — connects through the same six-symbol interface. The Main ABM (10,000 agents) shown elsewhere on this page is one example; the platform is not bound to it.
Browser-Anywhere Monitoring
Two real-time dashboards (Exchange :8080, Trader :8081) over WebSocket. Multiple viewers — researchers, students, collaborators — can observe the same simulation concurrently from any host on the network.
Tick-Level Persistence
Trade intents, LOB snapshots, and trade records persist to columnar Parquet. Configuration, seeds, and git hashes accompany every run, enabling exact replay and downstream econometric analysis.
Two Independent Components
The exchange and the trader pool are separate processes that meet at the order protocol. Each opens with a self-describing landing page, exposing the engine for inspection before any orders flow.

Exchange · :8080
A continuous double auction with strict price-time priority matching. Receives orders over ZMQ; publishes the order book and trades over WebSocket to any browser on the network.

Main ABM · :8081 · one of many possible models
The Main ABM (Goettler–Parlour–Rajan extended to 10,000 agents) is the trader model in this exhibit. Any other model — different decision rule, different population size, reinforcement learning, human-in-the-loop — connects through the same protocol without touching the engine.
Complete A-Share Trading Day — Native Implementation
Unlike general-purpose simulation frameworks that model only continuous auction, SMSS natively implements the complete trading day of the Chinese A-share market — directly applicable to research on price discovery during auctions and informed trading across market phases.
| Time | Phase |
|---|---|
| 9:15–9:20 | Opening Call Auction |
| 9:20–9:25 | Opening Call Auction |
| 9:25–9:30 | Opening Match + Indicative Price |
| 9:30–11:30 | Continuous Auction (AM) |
| 13:00–14:57 | Continuous Auction (PM) |
| 14:57–15:00 | Closing Call Auction |
③ An Application Example — Main ABM
The trader model running in this exhibit is the Main ABM— a 10,000-agent boundedly-rational population built in the spirit of Goettler, Parlour & Rajan, extended with continuous-time Poisson event flow, stochastic-approximation belief learning, and behavioral elements (disposition effect, stop-loss).
This is one model, not the only model. Any other trader population — different decision rule, different scale, reinforcement learning, behavioral experiment, human-in-the-loop — connects through the same protocol. What follows demonstrates what kind of research questions this platform can address, using this particular model as the running example.
Built on Goettler, Parlour & Rajan
The Main ABM builds on the computational equilibrium framework of Goettler, Parlour, and Rajan (Journal of Finance, 2005; Journal of Financial Economics, 2009) — one of the foundational models for understanding strategic behavior in limit order book markets.
This implementation extends the framework to 10,000 agents with continuous-time Poisson event flow, stochastic-approximation belief learningin the spirit of Pakes & McGuire (1994), and behavioral elements from finance literature (disposition effect, stop-loss zones). It enables the study of equilibrium convergence dynamics at a scale and behavioral richness previously inaccessible.
A Python prototype (v1) produced the empirical results for the doctoral thesis. The current Rust system (v2) re-implements the validated approach with engineered persistence, monitoring, and protocol layers — transforming a working research instrument into a sustainable platform.
Computational Equilibrium — Belief Convergence
The curves below show the Weighted Absolute Deviation (WAD) of agent belief distributions between successive measurement intervals. As WAD falls below the convergence threshold, the population's beliefs — their estimates of fill probability at each price level (μb for buy, μs for sell) and expected round-trip return (Tvalue) — have stabilized.
The learning is shared.Every agent's observed fill or non-fill updates a common belief table indexed by (system state, action), which all agents query when deciding their next action. This is computational equilibrium emerging from interaction, not designed in, and not solved analytically.
▶ The platform in research mode · Exchange Engine (left) and the Main ABM Trader Monitor (right) running in parallel

Two independent processes, one shared protocol. The exchange runs a continuous auction at ~67K orders/sec; the trader pool runs the Main ABM's 10,000 agents, sharing a common belief table indexed by (system state, action), updated by every fill any agent observes. The Belief Convergence panel (center-right) shows the WAD of the population's μs beliefs declining past the threshold — convergence emerging from interaction, not designed in.
μ_b WAD evolution · 12× timelapse · 372 testing rounds


μ_b — Buy-side fill belief
WAD declining from ~0.024 toward the convergence threshold over 306 testing rounds.

μ_s — Sell-side fill belief
Symmetric convergence on the sell side — different scale, same qualitative dynamic.
The Learning, Live — Main ABM Trader Monitor
The WAD curves above compress belief convergence into a single scalar. The clip below is the multi-panel raw viewof that same process: belief tables (μ_b / μ_s / Tvalue) updating with every fill and non-fill any agent observes; individual agents' net worth and holdings evolving through their trading; order flow intensity and distribution spreading across the screen simultaneously. After watching it, “10,000 agents learning through shared interaction” stops being an abstract phrase.
▶ Main ABM Trader Monitor · 45-second live clip showing the learning process (belief tables + individual agent tracking + order flow evolving in parallel)

Emergent Belief Structure
The belief distributions, plotted across 11 limit-order-book price levels (B5 … A5 around mid-price), reveal what agents have learned: the probability of buy-side and sell-side execution at each level. The shape of the learned belief surface emerges from market interaction; the action space and state representation are designed, the values they take are not.

μ_b profile across 11 LOB levels
Population-average buy-fill probability declines smoothly from deep ask (A5, ~1.0) to deep bid (B5, ~0.3) — the learned shape of the order book, not a designed prior.

μ_s profile across 11 LOB levels
Sell-fill probabilities form a complementary structure — what 10,000 agents have jointly learned about both sides of the market.
Inspectable at the Individual Level
Macro-level aggregates emerge from concrete trajectories of individual agents. Any agent in the population can be tracked: net worth, P&L, holdings, and trade history are recorded over the full simulation. Aggregate findings remain auditable down to a single trader — when 10,000-agent emergent dynamics produce a stylized fact, the scientific question is which subset of behaviors causes it, and individual-level inspection answers that.

Five concurrently tracked agents — net-worth trajectories, holdings, recent trades. Drawn from a live simulation of 10,000 agents.
Validated against real markets
Five canonical stylized facts of equity markets — leverage effect, volatility clustering, long-memory volatility, order flow autocorrelation, and excess kurtosis — emerge from agent interaction in the Main ABM, not as designed features.
Stylized Facts vs Real Markets
| Metric | SMSS | Real |
|---|---|---|
| Leverage Effect | 1.88 | 2.0 (DAX) |
| Long Memory d(|r|) | 0.504 | 0.48–0.55 (DAX) |
| GARCH Persistence | 0.980 | 0.989 (DAX) |
| Order Flow Hurst | ≈0.7 | ≈0.7 (Empirical) |
| Fat Tails (Kurtosis) | 3.67 | ~10 (DAX) |
Validation results obtained with the v1 Python implementation used for the doctoral thesis (Chapter 4); the v2 Rust system reproduces the same model dynamics, with re-validation in progress.
Built for the Long Run
The platform currently runs 10,000 agents at 15% engine utilization with the Main ABM. The architecture — distributed ZMQ communication, modular trader processes, network-accessible monitoring — supports multi-instrument, multi-machine, multi-trader-population deployment as research questions demand them.
Infrastructure designed to support a sustained line of computational microstructure research.
④ Where This Can Go
The Main ABM is one application; the platform supports many more. Below are research and teaching scenarios that the same engine — with different trader populations or configurations — can serve.
Research
Run large agent populations to study how individual learning aggregates into market-level equilibrium, with real-time visualization of the convergence process and full belief-trajectory data for analysis.
Plug different trader models into the same exchange to study how market properties change with agent heterogeneity, strategy composition, or information structure — the engine is shared, the model varies.
Test alternative auction rules, matching algorithms, or regulatory constraints in a fully instrumented environment with tick-level data capture and Parquet output for downstream econometrics.
Teaching
Students write their own trader models against the Python SDK and deploy them into a live exchange — turning microstructure theory into hands-on experimentation in a graded environment.
Real-time candlesticks, order book dynamics, and belief evolution displayed on screen — market microstructure made visible, with the lecturer free to pause, modify the schedule, or pose what-if questions live.
The protocol natively supports human participants trading via browser alongside AI agents — enabling controlled experiments in behavioral finance with the same exchange used for purely computational research.
⑤ Try It
A self-contained demo package — engine, trader pool, and both monitoring dashboards. Double-click to launch; no installation, no configuration, no dependencies.
Includes Exchange Engine, Main ABM (10,000 agents), and dual monitoring dashboards. The package runs locally; nothing is uploaded.
System Requirements
ⓘ First-run note
On first launch, Windows will show a SmartScreen warning (“unrecognized app”) for SMSS.exe because the demo binary is not code-signed. This is not a program error.
Click “More info” → “Run anyway” to launch.