By
Lachezar Kolev
February 2, 2026
4 minutes
At LimeChain, our R&D process usually follows a specific pattern: we find a complex system, we analyze it, and then we try to measure and recreate it.
Recently, I’ve spent a significant amount of time looking into router order flows and Prop AMMs on Solana. As a result, we published a research on how to make sense of these 'dark' protocols and built a benchmark environment to see how they behave under different conditions.
After working on the simulation tool, I was treasure hunting my X’s feed when I came across a quote from Richard Feynman that, lore has it, was found on his blackboard at the time of his death in 1988:
"What I cannot create, I do not understand."
This got me thinking - while simulations tell you what happened, they don't give you a clear picture of how **it actually happened at the execution level.
Benchmarking and analyzing simulations is one thing. But for me, the "Black Box" of a Prop AMM only truly opens when you have to write the code that interacts with it, handles its state, and routes a real transaction through it.
That realization motivated me to create Magnus - an open-source Solana aggregator.
In simple terms, I’ve created a tool designed to unify the components needed to integrate with various liquidity sources on Solana. This includes AMMs, Prop AMMs, and aggregators.
I tried to built it as a vehicle for understanding for developers - a repository where you can see the actual machinery required to connect to and execute against the most popular protocols on the network.
The system is made up of two core components:
The currently implemented liquidity sources include:
Because some (most) Proprietary AMMs are deliberately obfuscated, I bypassed the traditional route of locally storing deserialized state and manually computing swap amounts. Instead, the interactions are directly simulated through a built-in chroot-like shell. To maintain flexibility, all adapters require an implementation of an unified interface that abstracts away exchange-specific logic, allowing all liquidity sources to be treated interchangeably.
If you are a developer or researcher interested in high-frequency trading, you know that the speed vs. precision tradeoff is a constant struggle of building on Solana. This open-source aggregator provides a starting point to explore that tradeoff yourself.
There are three main ways I see people using this repo:
While our previous tool, pmm-sim, is great for historical benchmarking, this one offers real-time tracking that allows you to see how liquidity moves and how prices shift across different sources.
If you’re working on execution bots, Magnus provides the foundations for transaction construction and routing. Instead of starting from scratch with every new liquidity source, you can use the unified interface to interact with multiple protocols.
This is perhaps the most interesting use case. Magnus allows you to create your own execution algorithms. You aren't forced to use a built-in logic. Instead, you can experiment with how you want to handle slippage, which routes you prioritize, and how you bundle your instructions. It’s a basically a sandbox for finding your own balance between execution speed and price impact.
The code is live on GitHub: https://github.com/limechain/magnus
It is a fully working implementation, though I’ve left plenty of room for improvement. In the spirit of open-source R&D, you can regard it as a foundation.
If you’ve been reading the documentation for Solana protocols and feel like you're still missing the full picture, just clone the repo, look at the interaction logic, and try to reconstruct the swaps yourself.
That is how we truly understand the system.
Magnus is an open-source Solana aggregator developed by LimeChain. It is designed to unify the components needed to integrate with various liquidity sources on the Solana network, including Automated Market Makers (AMMs), Proprietary (Prop) AMMs, and other aggregators.
While simulations provide historical data, the creators felt that truly understanding the "Black Box" of Proprietary AMMs required writing the code that interacts with them at the execution level. Magnus serves as a vehicle for developers to learn how these complex protocols function.
Magnus consists of two primary parts:
The aggregator currently supports:
Because many Proprietary AMMs are deliberately difficult to analyze, Magnus bypasses traditional local state storage. Instead, it uses a built-in "chroot-like shell" to simulate interactions directly, using a unified interface that allows all liquidity sources to be treated interchangeably.
Magnus is primarily built for developers and researchers, specifically those interested in high-frequency trading (HFT), decentralized finance (DeFi) execution, and Solana protocol mechanics.
While it is a fully working implementation, the creators view it as a foundation with "plenty of room for improvement." It is intended to be a starting point for further research and development within the open-source community.
The repository is live and available on GitHub at: https://github.com/limechain/magnus
