Marko Sabec
TypeScript/Rust protocol engineering · 18+ yrs · Rain
“Trading needed stronger foundations. We built explicit Rust boundaries for research, backtesting, and execution.”
Marko came into the engagement an 18+ year software and protocol engineer based in Ljubljana, Slovenia, with recent blockchain leadership roles at MetaWealth and Solstake.tv, now a Senior Rust/Protocol Engineer at Rain working on multi-chain Solana, EVM, and Stellar payment infrastructure. Rather than a learning exercise, we scoped QuantForge, an open-source Rust framework for trading systems built on a hexagonal, ports-and-adapters architecture.
The build reached v0.2.0, around 5,800 lines of Rust in a single crate, with 4 core traits defining every venue integration and Decimal used everywhere instead of floating point for the money math. Dry-run safety is enforced at compile time, not by a flag that can be forgotten.
A trading framework that can't send a live order by accident
A trading system lives or dies on correctness under real money: a dry-run test that accidentally reaches a live venue is not a bug you get to discover twice. Getting that right in Rust meant designing the venue interface so an unsafe path doesn't compile, rather than just doesn't run.
That same discipline shaped the money math: every amount is a Decimal, never an f64, so rounding errors can't silently creep into a trade calculation.
- •Dry-run mode encoded as a type, not a runtime flag
- •Decimal used everywhere for trading math, never f64
- •4 core traits, every venue is an adapter behind the same ports
An open-source framework, v0.2.0 and counting
29 commits in, Marko has a public hexagonal Rust trading-systems framework at v0.2.0: ~5,800 lines, 4 core traits, compile-time dry-run safety, and a companion blog documenting the build decisions.
He's applying the same Rust skills in production too, as a Senior Rust/Protocol Engineer at Rain, building multi-chain Solana, EVM, and Stellar payment infrastructure.
- ✓QuantForge v0.2.0, public repo and blog
- ✓Compile-time enforced dry-run safety
- ✓Rust in production at Rain on multi-chain payment infra
Four explicit boundaries before the first venue integration
Marko came in with 18+ years of software engineering experience, most recently as a blockchain and protocol engineer leading Solana smart-contract work at MetaWealth and Solstake.tv. Rather than a toy exercise, we scoped QuantForge: an open-source Rust framework for trading systems, built on a hexagonal, ports-and-adapters architecture from day one.
- ✓4 core traits define the ports, every venue integration is an adapter behind them
- ✓Decimal used everywhere for money math, f64 never touches a trading calculation
- ✓Single Cargo crate, ~5,800 lines of Rust at v0.2.0
One CLI, separate trading boundaries
CLI
data · trade · monitor
Ports
exchange + storage traits
Engine
backtest + live
SQLite
candles + journal
Research, backtesting, live execution, and operator monitoring share explicit Rust boundaries instead of growing into one command-sized blob.
A dry run that cannot reach a live venue
The riskiest part of any trading system is accidentally sending a live order during testing. Marko's fix isn't a runtime check that can be skipped, it's encoded directly into the function signature: a venue handle typed as Option<&dyn TradingVenue>, so a dry run literally cannot reach the network, the compiler enforces it.
- ✓Dry-run mode is a type-level guarantee, not an if-statement that can be forgotten
- ✓Every venue plugs into the same 4-trait port, no special-casing per exchange
- ✓Protocol-engineering background (18+ years) shows up directly in the interface design
Dry-run cannot reach a venue
trade run
strategy intent
Dry-run
venue = None
No order
not callable
Live mode
explicit --mode live
Confirmation
--yes or interactive yes
QuantForge is a framework, not a tutorial repo
QuantForge sits at v0.2.0, built and documented in the open, with a companion blog tracking the build decisions as they happen. Marko is currently a Senior Rust/Protocol Engineer at Rain, working on multi-chain Solana, EVM, and Stellar payment infrastructure.
- ✓QuantForge v0.2.0 with a documented research, backtest, and execution path
- ✓Public repo and blog make the design tradeoffs inspectable
- ✓Rust skills already in production use across multi-chain payment infrastructure
The same bars drive research and execution
Candle sync
UTC epoch ms
Closed bars
Decimal values
Strategy
target position
Backtest
next-bar execution
Journal
run + order + trade state
The journey
One clear path through the build
Ports
Hexagonal architecture scoped: ports, adapters, 4 core traits.
Exact arithmetic
Decimal-everywhere math, never f64, for exact trading-system arithmetic.
Dry-run boundary
Dry-run mode enforced at compile time via Option<&dyn TradingVenue>.
Release
~5,800 lines of Rust, single crate, tagged and versioned.
Public system
QuantForge v0.2.0 and its design decisions documented in the open.
Drag to explore · Select a milestone to read the full story
Mentor perspective
Marko Sabec came with deep protocol experience and a clear trading goal. The work was about turning that experience into explicit Rust boundaries and resisting shortcuts. He applied the advice to make unsafe states hard to represent, then carried it through research, backtesting, dry-run safety, and execution.
Max Wells
Rustify mentor
Want a story like Marko's?
Available for callsMax Wells
Founder · Rustify
Book your Rust career diagnostic
30 minutes, 1:1 with Max. An honest read on where you are and whether Bootcamp or Mentorship fits, before you apply.
Only a few diagnostic slots left this week.
Applications are reviewed carefully.
More client journeys
See another path into Rust
Joseph Swager
25+ yrs · Security engineering
Senior engineer building a serious Rust platform around explicit system boundaries
Andrés Gutiérrez Ramírez
10+ yrs · Architecture/backend systems
Architecture and backend systems depth applied to a focused Rust project
