# Whitepaper ### Abstract Loadout is a platform for indie and AA game developers to launch, fund, and distribute their games using open, market-driven mechanics. Developers showcase playable demos, design documentation, trailers, and team information while launching a token that allows the market to fund development in real time. Investors participate on the same terms from launch. No private rounds and no discounted tokens. Where team allocations exist, vesting is enforced on-chain and fully visible. Everyone enters on the same curve, with the same rules. Projects raise capital through continuous token trading rather than presales or private allocations. A 5% fee on every trade routes capital directly to game development, allowing funding to scale with attention and demand rather than through fixed fundraising rounds. Built on Solana, Loadout focuses on the indie and AA segment where tens of thousands of games release each year but access to early-stage capital remains limited. The platform gives developers a way to secure funding without publishers or equity dilution, while giving investors early access to real games with liquidity from day one. ### The Problem We're Actually Solving Crypto gaming had one thing that worked absurdly well: capital formation. For five years, crypto markets have shown they can mobilise liquidity faster than any normal path in games. The issue is where that money went. It mostly went into a small pool of crypto-first studios, in an industry where shipping a successful game is already hard enough, even when everyone wants you to win. So you got a predictable mess. Many inexperienced teams raised significant amounts of money, but there weren’t enough real games shipping to build a proper sample size. Mainstream developers stayed away because the stigma was already set. The industry hated crypto, so players did too. Once that happens, you’re playing the game on nightmare difficulty. The part I had wrong for years is this: even if a crypto-first studio builds an incredible game, they're still fighting an entire industry that wants them to fail. That's insane. You're trying to do one of the hardest things in entertainment while carrying a label that makes people instantly suspicious. It's almost destiny that most of these projects don't break through. Loadout flips it. Instead of trying to convince the gaming industry to accept crypto-native studios, we bring mainstream developers to the liquidity. This also fixes the investor side. Crypto gaming investors have spent years gambling on teams that had never shipped a game, simply because there weren’t enough real ones in the pool. Loadout gives them curated projects with demos, docs, and actual teams they can judge, with access from the earliest possible stage. Imagine investing in Palworld pre-demo. Ridiculous. We give teams a way to tap into crypto capital early without forcing them into a specific design philosophy. If a team wants to go deep on Web3, great. If they want to keep the game completely normal and just use the market as a funding rail, also great. The point is: the game comes first, and the funding layer adapts around it. If we attract mainstream developers at scale, the stigma collapses through sheer volume of shipped titles. Steam sees around 15,000 new titles a year. If a meaningful number of those teams can fund through Loadout, crypto stops being "crypto games" and starts being what it should have been the whole time: a capital rail for game development. That's why this works. It takes the best of Steam and Kickstarter and plugs them into an existing, working liquidity engine. Developers get funding without publishers and without giving up equity. Investors get early access on the same terms as everyone else, with no hidden VC discounts. Players get better games because teams actually have runway to finish what they started. This should be the obvious choice for any game studio that wants early funding and attention while retaining full control over how their game is designed. ### How Loadout Works A developer creates a project on Loadout by publishing the core materials investors and players need to judge a game early: trailer and screenshots, demo access, design documentation, team background, roadmap, token model, and use of funds. The page is built to answer the basic questions quickly and transparently. Once the project page is live, the developer launches a token directly through Loadout. There are no presales, whitelists, or private allocations. Trading starts immediately. Anyone can buy, anyone can sell, and price is set by demand from the first trade. On every trade, a 5% fee is collected. 4% routes straight into the project treasury. The remaining 1% goes to the Loadout protocol, which funds the referral system and platform operations. This is the core loop: attention turns into capital without freezing the market. Projects graduate automatically once the bonding curve reaches 60 SOL. Graduation creates a permanent Meteora DLMM liquidity pool with locked LP, giving the token deeper liquidity and the project increased visibility on the platform. From there, the model compounds. Developers keep building and shipping updates. Investors and players track progress through public milestones. The token remains liquid throughout, while ongoing market activity continues to fund development through trading fees. Loadout is designed so that the best games rise because they hold attention long enough to build communities and capital. The platform provides the rails. The market does the sorting. ### Launch Types Loadout offers two launch types. Both use the same fee model, bonding curve, and graduation mechanics. The difference is in token allocation. #### Fair Launch 100% of the token supply goes directly to the market from day one. No team allocation, no treasury token allocation, no vesting. Every token is circulating, every participant is on equal footing, and there's zero structural sell pressure from insider holdings. Fair Launch works best for solo developers, small teams, or projects that want maximum credibility with traders. The team funds itself entirely through trading fee capture into the project treasury. #### Studio Launch Studio Launch lets developers reserve a portion of the token supply for team and treasury allocations. Each is configurable between 0 and 20%, with a combined maximum of 40%. All reserved tokens are subject to mandatory linear vesting with a configurable cliff and duration. Preset options are 6, 12, or 24 months. Allocations are enforced on-chain at project creation and cannot be modified after launch. Vesting schedules are transparent and visible on every project page. Traders can see exactly what's locked, what's vested, and when tokens unlock. Project admins can revoke unvested tokens from a beneficiary at any time, but the beneficiary always keeps whatever has already vested. | **Parameter** | **Simple Launch** | **Custom Launch** | | ----------------------- | ------------------------- | ------------------------------- | | Circulating Supply | 100% | 100% minus allocations | | Team Allocation | None | 0 to 20% | | Treasury Allocation | None | 0 to 20% | | Max Combined Allocation | N/A | 40% | | Vesting | None | Linear (6/12/24 months) | | Funding Source | Treasury fee capture only | Fee capture + token allocations | ### Bonding Curve and Price Discovery Each project token starts trading through a constant product bonding curve. Price moves as demand moves. Buyers can enter immediately, and sellers can exit immediately. There's no private round sitting in the wings. Where team allocations exist on Custom Launches, they're enforced through on-chain vesting and visible to every trader before they buy. #### How the Curve Works The bonding curve uses a constant product formula, the same core model behind Uniswap and other battle-tested DEXs. The invariant (k) is established at project creation and must be maintained or increased after every trade. All arithmetic runs on 128-bit checked operations with ceiling division that always favours the protocol, eliminating rounding exploits. Each project starts with virtual reserves that set the initial price depth. The default is 30 virtual SOL paired against the full token supply. Real reserves start at zero and grow as trading happens. Early buyers get tokens at lower prices, and the price rises along the curve as more SOL flows in. #### Slippage Protection Every trade requires a mandatory minimum output parameter. For buys, you set a minimum number of tokens you'll accept. For sells, you set a minimum SOL amount. If the trade would return less than that, it reverts. This protects traders from front-running and unexpected price movements. ### Fees and Funding Flows Loadout is built so capital moves automatically. Developers shouldn't need to fundraise, negotiate, or rely on manual payouts. Investors shouldn't need to trust a team's promise to "use the money well" without being able to see what's happening. The fee model is simple: 5% on every swap. | **Recipient** | **Fee** | **Purpose** | | ---------------- | ------- | ----------------------------------------------------- | | Project Treasury | 4% | Funds game development directly | | Loadout Protocol | 1% | Platform operations, referral rewards, trader rebates | Think of it like NFT royalties. For years, NFTs carried 5 to 10% creator fees on every trade and nobody blinked. Traders accepted it because the creator gets paid. Same energy here. 4% goes straight to building the game. The remaining 1% keeps the platform running and funds the referral system that drives growth. This fee model works because Loadout owns the liquidity. Pre-graduation, the bonding curve holds the entire token supply. Post-graduation, the Meteora DLMM pool is seeded with the deepest liquidity available for that token, and the LP is permanently locked. Anyone trying to set up a competing pool with lower fees would need to put up serious capital, and even then aggregators like Jupiter route to the deepest pool. The fee savings on a thinner pool get wiped out by slippage. The 1% protocol fee doesn't just go to Loadout. A significant portion flows back to the community through the referral and rebate system, covered in the next section. All splits are transparent on each project page. Every project uses the same fee model. That consistency is important. It allows investors to compare projects quickly and prevents teams from shipping tokenomics that are impossible to understand. The same 5% fee structure applies both pre-graduation on the bonding curve and post-graduation on the Meteora DLMM pool. Wallet-to-wallet transfers are untaxed. Fees only apply to swaps. The platform does not dictate how a studio spends treasury funds. It makes treasury balances and flows visible on-chain and gives teams the tools to communicate their plans for capital deployment over time. ### Referral System Loadout has an on-chain referral system built to incentivise organic growth. Anyone can register their wallet as a referrer, which generates a unique shareable link. When someone trades using that link, rewards are distributed automatically from the protocol fee. No additional cost to the trader or the project. #### How It Works When a referral is active, the 1% protocol fee on each trade splits three ways: * Referrer Reward: 40% of the protocol fee goes to the referrer * Trader Rebate: 20% of the protocol fee is returned to the trader as a rebate * Protocol: The remaining 40% goes to Loadout Without a referral, the full 1% goes to the protocol. All referral state is stored on-chain. Self-referral is blocked at the contract level. Rewards accumulate in referrer and rebate accounts and can be claimed at any time. ### Graduation and Liquidity Graduation is the point where a project moves from the initial bonding curve into deeper, permanent liquidity. A project graduates automatically once 60 SOL has been deposited into the bonding curve. Every project, same threshold. #### What Happens at Graduation When the bonding curve hits 60 SOL, anyone can trigger graduation. The process is fully automated and happens in two on-chain transactions. First, the bonding curve shuts down. No more buys or sells on the curve. SOL and token reserves transfer to the graduation authority, and a Meteora DLMM liquidity pool is created and seeded with the project's reserves. Second, the LP position is permanently locked. The project admin cannot withdraw liquidity. Ever. The project state transitions to Graduated, and the 5% fee continues on the Meteora pool. The LP is permanently locked. That means post-graduation liquidity can never be rug-pulled. Project admins can still claim accumulated trading fees from the locked LP position, which provides ongoing development funding. But the liquidity itself stays. Projects can keep building beyond graduation and continue raising capital. The token remains liquid. The treasury keeps growing. The game keeps shipping. ### Project Lifecycle Every project on Loadout follows a clear state machine with four stages: | **State** | **What's Happening** | **Trading** | | ---------- | ----------------------------------------------------------------------- | ----------- | | Draft | Project created, token minted, mint authority revoked. Awaiting launch. | Disabled | | Live | Bonding curve active. Buys and sells enabled. Treasury accumulating. | Enabled | | Graduating | Bonding curve hit 60 SOL. Meteora pool being created, LP being locked. | Paused | | Graduated | LP permanently locked. Trading continues on Meteora DLMM. | Enabled | Mint authority is revoked immediately when the token is created. This means the project admin, or anyone else, can never inflate the token supply after launch. The total supply is fixed permanently from the moment the project is created. #### Scheduled Launches Projects don't have to go live immediately. Loadout supports scheduled launches through an on-chain executor role. A project can sit in Draft with a future launch time, and the platform's automation system will move it to Live at the specified moment. This lets teams coordinate launch timing with marketing, community events, or announcements. ### Vesting For Custom Launch projects that reserve team or treasury allocations, Loadout enforces vesting through a dedicated on-chain program. This isn't optional. If you take an allocation, it vests. Vesting is linear with a configurable cliff. After the cliff passes, tokens unlock proportionally over the vesting duration. Beneficiaries can claim their vested tokens at any time after the cliff. Project admins can revoke unvested tokens from a beneficiary, but the beneficiary always keeps whatever has already vested. This gives teams flexibility to handle departures while protecting people who've earned their allocation. All vesting schedules, cliff dates, claimed amounts, and unlock timelines are visible on-chain and displayed on the project page. Traders can see exactly how much of a team's allocation is still locked at any point in time. ### What Developers Actually Get Loadout is built to solve one thing for developers: runway. A studio can launch a project page, ship a demo, and start accumulating capital immediately through open trading. There's no pitch process, no equity dilution, and no waiting for a publisher to decide the game fits their slate. The treasury is SOL. It can be used to keep the team alive, pay contractors, increase content output, and fund marketing. Because capital is raised in-market, the amount a team can raise scales with demand instead of being capped by a single funding round. After graduation, the model shifts from one-time funding to ongoing funding. Trading fees from the locked Meteora LP continue contributing to the treasury. That allows teams to keep building without relying on periodic token sales to finance ongoing work. Loadout also functions as a distribution channel. Each project page is designed to convert attention into something useful: wishlists, community, and eventually purchases when the game is live. Over time, projects build an audience before release rather than trying to find one after launch. Developers don't need to be crypto-native to use the platform. They need to ship game content, communicate clearly, and keep hitting milestones. The market does the rest. ### What Investors Get Loadout is designed around early access and clean market structure. When a token launches on Loadout, trading is open from the first moment. There are no private rounds and no discounted tokens sitting off-platform. Where Custom Launches include team allocations, vesting schedules are enforced on-chain and visible from day one. Everyone enters on the same curve, with the same rules. Investors can evaluate projects using demos, documentation, team background, roadmap, and funding plans are available up front, alongside live market data and treasury progress. That makes it possible to price execution early, before distribution and revenue are fully visible. The referral system means active community members earn ongoing rewards for bringing others to projects they believe in. Trader rebates return a portion of fees to active participants. Both are claimable on-chain at any time. Liquidity is available throughout the lifecycle. Tokens can be bought and sold before graduation, and they continue trading after graduation through deeper Meteora DLMM pools. As projects progress, milestone delivery becomes a visible signal that the market can price in real time. Loadout is not built to force holding. It's built to let the market express conviction early, reprice as new information arrives, and keep capital flowing to the teams that continue to deliver. ### Curation, Quality, and Failure Loadout is open by default. Anyone can try to launch a project, and the market decides whether it matters. That also means some projects will be weak. Some teams will overestimate what they can ship. Some launches will be driven mostly by hype. This is part of the environment. Trying to filter it out completely would push Loadout toward manual gatekeeping and slow approvals, which defeats the point of the platform. Instead, Loadout focuses on two things: friction where it matters, and transparency everywhere. Projects are required to publish enough information to be evaluated early. The platform requires a game design document and encourages demos, trailers, documentation, team details, and clear use of funds. Treasury flows are visible on-chain. Graduation requires 60 SOL in the bonding curve, which is difficult to fake. The result is a natural sorting mechanism. Projects that keep attention raise capital and graduate. Projects that don't, fail. Over time, reputation compounds for teams that ship and for projects that maintain real communities. Loadout doesn't need every launch to be good. It needs the best launches to be obvious and the rules to be consistent. ### Built on Solana Loadout runs on Solana for one reason: it makes the core loops viable at scale. Low fees and fast settlement matter when you're asking investors to trade frequently and developers to rely on on-chain funding flows. #### On-Chain Programs The on-chain system is built around three Anchor programs and a shared math library. Loadout Core is the primary program. It handles protocol configuration, project creation, token minting, bonding curve trading (buy and sell), fee routing, referral registration and rewards, trader rebates, and the first phase of graduation. All protocol-level parameters like fee rates, referral splits, executor authority, and pause state are stored in a singleton FeeConfig account. The Graduation program handles Meteora DLMM pool creation, initial liquidity deposit, and permanent LP locking. It also provides fee claiming from the locked LP position for ongoing project funding. The Vesting program enforces linear vesting with cliff support for Custom Launch allocations. It supports claiming vested tokens and admin revocation of unvested portions. Loadout Math is a no\_std Rust library implementing the constant product AMM formulas. All arithmetic uses 128-bit checked operations with ceiling division to eliminate overflow and rounding exploits. #### Security The platform is designed around a few core security principles. All arithmetic uses checked operations. Overflow-checks are enabled in the Solana release profile. The math library uses u128 throughout with ceiling division that always favours the protocol. Access control is enforced through Anchor discriminators, PDA constraints, and a two-step admin transfer process. State machine guards prevent invalid transitions. You can't buy when a project isn't Live. A global pause flag can halt trading and launches but doesn't affect graduation or vesting claims. Economic safety comes from graduation thresholds that require 60 SOL in the bonding curve, mandatory slippage protection on every trade, enforced fee caps (max 5% per component, 10% combined hard cap), and verification that the constant product invariant holds after every swap. Mint authority is revoked at token creation. Permanent and irreversible. Nobody can inflate the supply after launch. The platform is built so investors can verify mechanics by looking at on-chain activity, and developers can rely on automated flows rather than manual payouts. ### Discovery and Distribution Loadout is both a funding platform and a discovery surface. Projects are surfaced through multiple feeds: trending, newly graduated, graduating soon, top wishlisted, and new launches. Traders and players can filter by stage, launch type, and genre. Each project page shows live market data, treasury progress, holder count, volume, and the team's updates. Wishlisting creates an early signal of interest that works for both sides. Investors can track projects before committing capital. Developers build a community before they even launch. Project updates let teams post progress directly on-platform, keeping their community informed without relying on external channels. Over time, Loadout will add direct game purchasing and access pass integration, turning the platform into a full distribution channel where funding, community building, and game delivery all happen in one place. ### Team Loadout is being built by people who have already shipped in Web3 at scale and know what it takes to build product, liquidity, and community. Founder: Kieran Warwick * Founder of Illuvium * Built one of the most recognised gaming brands in Web3 * Operated through multiple market cycles with a global community of over 1 million members * Built and shipped 4 gaming titles What matters for Loadout is simple: this platform needs distribution, trust, and execution. My edge is that I can bring the market to the platform early, and I've already lived the reality of building a large Web3 gaming project. I know what has worked, and what has failed, and how to solve those pitfalls. ### Roadmap #### Phase 1: Launch * Project creation with full metadata, demos, trailers, and documentation * Bonding curve token launches (Simple and Custom) * Treasury capture and automatic graduation to Meteora DLMM * Referral system with trader rebates * Scheduled launches via on-chain executor * Watchlists and project discovery feeds * Vesting enforcement for Custom Launch allocations #### Phase 2: Growth * Post-graduation liquidity tooling and analytics * Market analytics and enhanced project dashboards * Enhanced project dashboards for developers * KOL and creator programs #### Phase 3: Distribution * Direct game purchasing on-platform * Access passes integrated with game delivery * Creator tooling and ecosystem programs ### Risks Loadout is a market-based platform. It carries the same risks as any open trading environment, plus the added reality that game development is unpredictable. Projects can fail. Teams can miss timelines. Demos can look promising and still not translate into a finished product. Tokens can be volatile. Liquidity can disappear quickly when attention moves elsewhere. Investors should assume that many projects will fail and size positions accordingly. There are also risks tied to manipulation. Some launches will be driven by hype. Some teams will attempt to inflate signals. The platform is designed to make key milestones difficult to fake, but it cannot remove adversarial behaviour entirely. Regulatory risk exists across global crypto markets. Loadout is built to avoid presale mechanics and private allocations, and the platform does not promise returns. That said, the regulatory environment is still evolving and can change quickly. Finally, Loadout is software. Smart contracts can have bugs. Frontends can have issues. Operational mistakes can occur. The approach is to reduce complexity, audit core contracts, and keep critical flows transparent and verifiable on-chain. ### Closing Loadout is built for a specific gap in the market: real games that need capital early, and capital that wants access before outcomes are already priced in. Developers publish a project the way it should be judged: demo, documentation, team, roadmap, and a clear plan for funds. Investors get a live market from the first trade, without private rounds or discounted entries. Where allocations exist, vesting is transparent and on-chain. Capital routes into game development automatically through treasury capture and post-graduation fee sharing. The platform doesn't decide which games deserve to succeed. It provides consistent mechanics, transparent flows, and a discovery surface that makes good projects easier to find. Teams that keep shipping attract deeper liquidity. Projects that don't will fail. Loadout is a funding layer, a launch layer, and eventually a distribution layer. The core thesis is simple: if a game can hold attention, it should be able to turn that attention into runway. --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://loadout.gitbook.io/product-docs/whitepaper.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.