my_project/
|-- Cargo.toml          # Project manifest and dependencies
|-- Cargo.lock          # Locked dependency versions (auto-generated)
|-- src/                # Source code directory
|   |-- main.rs         # Entry point for binary crates
|   `-- lib.rs          # Entry point for library crates
|-- tests/              # Integration tests
|-- benches/            # Benchmarks
|-- examples/           # Example programs
|-- target/             # Build artifacts (gitignored)
`-- README.md           # Project documentation


my_app/
|-- Cargo.toml
`-- src/
    |-- main.rs         # Required entry point
    `-- bin/            # Additional binaries (optional)
        `-- other_tool.rs


my_lib/
|-- Cargo.toml
`-- src/
    `-- lib.rs          # Required entry point


my_project/
|-- Cargo.toml
`-- src/
    |-- main.rs         # Binary entry point
    `-- lib.rs          # Library entry point


src/
|-- main.rs
|-- config.rs           # Single-file module
`-- utils.rs            # Single-file module


[workspace]
members = [
    "crates/core",
    "crates/cli",
    "crates/api",
    "shared",
]

[workspace.dependencies]
serde = "1.0"
tokio = "1.0"


// src/calculator.rs
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_add() {
        assert_eq!(add(2, 2), 4);
    }
}


tests/
|-- common/             # Shared test utilities
|   `-- mod.rs
|-- integration_test1.rs
`-- integration_test2.rs


# Rust
/target
**/*.rs.bk
*.pdb
Cargo.lock  # For libraries

# IDE
.idea/
*.swp
*.swo
.vscode/
*.code-workspace

# OS
.DS_Store
Thumbs.db

# Environment
.env
*.env.local


edition = "2021"
max_width = 100
use_small_heuristics = "Max"
imports_granularity = "Crate"
group_imports = "StdExternalCrate"


use std::env;
use std::fs;
use std::path::Path;

fn main() {
    // Copy assets to output directory
    let out_dir = env::var("OUT_DIR").unwrap();
    let dest_path = Path::new(&out_dir).join("config.toml");
    fs::copy("assets/config/default.toml", dest_path).unwrap();
    
    // Rerun if changed
    println!("cargo:rerun-if-changed=assets/");
}


Keep modules focused on a single responsibility

Prefer flat module structures when possible

Use snake_case for file and directory names

Use descriptive names that indicate purpose

src/
|-- domain/         # Business logic
|-- application/    # Application services
|-- infrastructure/ # External services
`-- presentation/   # API/CLI layer


[features]
default = ["std"]
std = []
async = ["tokio", "async-trait"]
serde_support = ["serde", "serde_json"]


[dependencies]
# Core dependencies
serde = { version = "1.0", features = ["derive"] }

# Optional dependencies
tokio = { version = "1.0", optional = true }

[dev-dependencies]
# Test dependencies
criterion = "0.5"
mockall = "0.11"

[build-dependencies]
# Build script dependencies
cc = "1.0"


Rust Project Layout

Creating a large-scale trading engine requires careful architectural planning to ensure high performance, low latency, and scalability. Below is a high-level architecture design for your trading engine that leverages HTTP, WebSocket, and FIX protocol.

• **HTTP API**: For standard request-response interactions.

• **WebSocket API**: For real-time data delivery and bi-directional communication.

• **FIX API**: For institutional clients and high-frequency trading.

• **API Gateway**: Handles and routes HTTP and WebSocket requests. This layer ensures security (authentication and authorization), rate limiting, and request validation.

• **Load Balancer**: Distributes incoming connections from clients to multiple instances of trading servers to ensure even load distribution and high availability.

• **Trading Engine**: High-performance, low-latency engine that handles order matching, order book management, and execution.

• **Quote Aggregator**: Aggregates quotes from liquidity providers in real-time.

• **Order Router**: Routes orders to the appropriate liquidity provider based on the best available price and execution policies.

• **Market Data Feeds**: Consumes and processes real-time market data from multiple liquidity providers.

• **Normalization Layer**: Normalizes data from various formats to a unified format.

• **Market Data Distributor**: Distributes processed market data to clients via WebSocket or HTTP endpoints.

• **FIX Connectors**: Connects to liquidity providers using FIX protocol.

• **WebSocket/HTTP Connectors**: Connects to liquidity providers using WebSocket or HTTP APIs.

• **High-Performance Databases**: For storing order books, trade history, and market data.

• Use in-memory databases (e.g., Redis) for real-time data.

• Use relational databases (e.g., PostgreSQL) for transactional data.

• Use NoSQL databases (e.g., Cassandra) for scalable market data storage.

• **Monitoring Tools**: Tools like Prometheus and Grafana to monitor system health, performance metrics, and alerting.

• **Centralized Logging**: Utilizing ELK Stack (Elasticsearch, Logstash, Kibana) for log aggregation and analysis.

• **DDoS Protection**: To protect against distributed denial-of-service attacks.

• **WAF (Web Application Firewall)**: To filter and monitor HTTP/HTTPS requests.

• **Encryption**: SSL/TLS for data-in-transit and encryption for data-at-rest.

• **Clients**: Various clients such as web platforms, mobile apps, and institutional traders use the HTTP, WebSocket, and FIX APIs to interact with the trading engine.

• **API Gateway**: Manages all incoming API requests. Examples: Kong, NGINX, AWS API Gateway.

• **Authentication & Authorization**: JWT tokens, OAuth.

• **Rate Limiting**: To prevent abuse and ensure fair usage.

• **Load Balancer**: Examples: HAProxy, NGINX, AWS Elastic Load Balancing, Google Cloud Load Balancing.

• **Trading Engine**: Developed with languages known for high performance (e.g., C++, Java).

• **Order Matching Algorithm**: FIFO, Pro-Rata, etc.

• **Quote Aggregator**: Receives and aggregates quotes from liquidity providers continuously.

• **Order Router**: Implements smart order routing (SOR) to achieve optimal execution.

• **Market Data Feeds**: Interfaces with market data providers.

• **Normalization Layer**: Unifies data formats across different providers.

• **Market Data Distributor**: Distributes real-time data to subscribed clients.

• **FIX Connectors**: Handles connections to liquidity providers via the FIX protocol.

• **WebSocket/HTTP Connectors**: Manages connections using WebSocket or HTTP APIs.

• **In-memory Databases**: For high-speed data access (e.g., Redis).

• **Relational Databases**: For reliable transactional data storage (e.g., PostgreSQL).

• **NoSQL Databases**: Handles large volumes of market data (e.g., Cassandra).

• **Prometheus/Grafana**: Metric collection and visualization.

• **ELK Stack**: Centralized logging and log analysis.

• **DDoS Protection**: Services like Cloudflare.

• **WAF**: Protection against web attacks.

• **Encryption**: Ensuring secure data transfer and storage.

• **Horizontal Scalability**: Adding more servers to handle increased loads.

• **Microservices Architecture**: Decoupling services to independently scale and manage.

• **Auto-Scaling**: Leveraging cloud auto-scaling features to dynamically manage resources based on load.

• **Languages**: C++, Java, Node.js, Python.

• **APIs**: REST, GraphQL, FIX protocol.

• **Databases**: PostgreSQL, Redis, Cassandra.

• **Hosting**: AWS, Google Cloud, Azure.

Blog.

Hello Algo724

More Stories

Rust Project Layout

Cadenza design note