Luca Galante’s Poncle Presents: building a fair path for small teams, honest launches and beyond

25 September 2025
General
10 min.
WhatsAppMessengerLinkedInRedditPinterestBufferSMS
Luca Galante’s Poncle Presents: building a fair path for small teams, honest launches and beyond

Summary:

We explore the mindset behind Poncle Presents, the publishing arm born from the runaway success of Vampire Survivors. Luca Galante has been frank about practices he dislikes in this space: publishers that exploit platforms, ship unfinished projects, and abandon players when the quick win doesn’t materialize. The alternative he describes is refreshingly simple—back genuine games, keep teams small and focused, price fairly, and continue supporting releases after launch regardless of initial sales spikes. That approach values trust over trends. It also sets clear boundaries on monetization and creative control so developers can realize their vision while players get stable, respectful updates. With early examples like Berserk or Die and Kill the Brickman, the principles are already visible: compact design, readable hooks, and pricing that matches scope. We break down how project selection works, which services matter most for tiny studios, and how learnings from Vampire Survivors—on communication, iteration, and community tone—translate into a healthier publishing playbook that aims to “share the luck” rather than squeeze the moment.

The spark behind Poncle Presents

Poncle Presents didn’t arrive in a vacuum; it emerged after Vampire Survivors surprised everyone by turning scrappy, low-friction design into a runaway hit across PC and consoles. That success created something more valuable than a budget line—it created perspective. When you’ve watched a tiny prototype gather momentum without manipulation, you learn which forces help and which ones bend a project into a shape that serves spreadsheets instead of players. The timing also tracks with a market that’s oversupplied and under-trusting. Players are wary of unfinished launches, confusing monetization, and promises that wilt by month two. Indie teams feel that pressure even harder: they need funding and platform support, but not at the cost of their identity. This is the gap Poncle Presents steps into. The aim isn’t to flood storefronts; it’s to curate small, punchy projects that can ship clean, iterate responsibly, and grow at a human pace. When we say “share the luck,” we mean turning one studio’s lessons into a repeatable path where scope stays honest, updates stay punctual, and everyone knows what they’re getting before they click buy.

What “genuine games” means and how we translate that into action

“Genuine” isn’t a vibe; it’s a checklist. It starts with a clear core loop that’s fun on a blank-slate save file. It favors responsive inputs, readable feedback, and a first session that sells the pitch without a cinematic crutch. It also rejects design that disguises grind as content. On the production side, “genuine” means cutting features that don’t carry their weight, launching only when stability meets the bar, and communicating what’s in scope versus what’s aspirational. That honesty extends to pricing: we match cost to scope and avoid psychological tricks that bloat baskets at checkout. Finally, “genuine” means the road after 1.0 is part of the plan. A small team doesn’t need twelve modes; it needs one brilliant backbone and a roadmap that respects bandwidth. If updates slip, we say so early. If a feature underperforms, we prune it and explain why. The result is fewer surprises, fewer refunds, and a tighter bond between creators and players.

Why calling out exploitative publishing practices helps players and devs

There’s a difference between being business-minded and being extractive. The behavior that erodes confidence is easy to spot: shipping in an unstable state, stretching “early access” indefinitely, or walking away the moment a chart doesn’t pop. That pattern burns audiences and buries promising teams. Saying it out loud matters because it sets a line in the sand. When a publisher publicly rejects those tactics, developers gain cover to protect their vision and players know what standards to expect. It also challenges a quiet assumption: that success requires aggressive monetization and relentless feature creep. In reality, small projects thrive when friction is low and decisions are legible. If the pitch is “clean arcade energy for five bucks,” then the loop must be sharp, the build must be solid, and post-launch care must be visible. No bait, no switch—just a fair trade between time, money, and delight.

How post-launch support builds trust even when sales are modest

Support after launch is where reputations are made. The goal isn’t to turn every project into a forever-service; it’s to prove that we won’t vanish once the first weekend ends. That can mean bug-fix waves, small quality-of-life tweaks, or a modest content drop that deepens replayability without resetting the skill ladder. Consistency is the superpower. When players see steady patches and transparent notes, they invest more confidently—leaving reviews, telling friends, and returning for new runs. For teams, the upside is stability: a manageable cadence that builds a library of learnings to carry into the next project. The key is aligning ambition with staff hours. A two-person outfit can’t promise a theme-park calendar, but it can promise reliability. That promise, kept, becomes the brand.

The small-team thesis: compact scope, fair price, strong identity

Small teams win by staying small in spirit. Compact scope gives polish room to breathe, fair pricing lowers the barrier to try, and a strong identity makes screenshots do the marketing. Instead of chasing thirty systems, we back games with two or three great ones that combine in surprising ways. That focus also keeps the testing matrix sane, which directly improves day-one stability. Players feel the difference in the first fifteen minutes: the controls click, the rewards land, and they understand what mastery will look like tomorrow. If a project needs a steep discount to feel worth it, we mis-scoped. If it feels underpriced, we did it right. That equilibrium isn’t guesswork; it’s the output of repeated playtests, trimmed features, and a relentless defense of clarity over clutter.

Selecting projects: signals we look for and red flags we avoid

Great pitches share the same fingerprints. We look for prototypes that make us grin in sixty seconds, teams that articulate what they won’t build, and feature lists that read like a menu, not a buffet. We also listen for healthy stubbornness: a willingness to cut beloved ideas in service of flow. Red flags are just as consistent—dependence on buzzword tech, monetization plans that eclipse design, and roadmaps that assume miracles. If you can’t explain how your next three patches improve first-run fun, the foundation isn’t ready. Conversely, when a developer can show a tight loop, a short backlog, and a patch plan tied to player friction points, that’s a green light. Our job then is to fund, test, localize, and market without seizing the wheel.

Funding and services without creative control grabs

Support should feel like oxygen, not handcuffs. We focus on the unglamorous work that moves needles for tiny teams: milestone funding that matches burn, QA that simulates real hardware chaos, localization that preserves tone, and platform coordination that clears certification with minimal churn. Marketing stays lightweight and honest—feature-first trailers, clarity on price and scope, and creator outreach that invites real feedback. Legal scaffolding matters too; contracts should be readable without a translator and structured so that success pays the people who made it. The outcome we want is simple: when developers talk about the experience later, they describe a partner who lifted weight, not a boss who rewrote the pitch.

The monetization stance: cosmetics optional, respect mandatory

We’re wary of designs that treat wallets like gameplay. If cosmetics exist, they’re optional and cleanly separated from power. Battle passes don’t make sense for a compact release unless they carry genuine, fresh play value and don’t hijack pacing. Price should reflect scope, and scope should reflect the lives of the people making the game. That alignment prevents “content for content’s sake” and protects the loop that made the prototype sing in the first place. The quickest way to deflate goodwill is to hide delight behind a credit card. We’d rather sell a small game fairly, then earn the right to add a little more once players ask for it.

Early examples: Berserk or Die and Kill the Brickman

We can already point to real releases that embody these principles. Berserk or Die leans into an audacious keyboard-bashing control scheme that trades complexity for catharsis. It’s priced to match scope and built to deliver immediate, arcadey feedback without a mountain of onboarding. Kill the Brickman pulls a different lever: turn-based rogue-like brick-busting with loadout tinkering that rewards curiosity over twitch. Both projects are small by design, confident in identity, and launched with clear expectations around price, feature set, and stability. Neither claims to be the next hundred-hour epic; both aim to be a tonight-and-tomorrow obsession you can explain in one breath. That is the publishing thesis in motion—tight, playful ideas that respect time and wallets while leaving space to grow if players want more.

Community transparency and how we communicate progress

The conversation with players starts before launch and never pretends to be something it’s not. Devlogs and patch notes prioritize what changed, why it changed, and how it impacts the first session. If we cut a feature, we say so and explain the tradeoff. If a bug slips, we triage in public and track the fix in plain language. That style isn’t just nice; it’s efficient. It reduces speculation, channels feedback into actionable buckets, and turns your most engaged players into allies who help test edge cases. When done consistently, transparency becomes a flywheel: better expectations lead to better reviews, which lead to steadier sales and calmer roadmaps.

Lessons learned from Vampire Survivors and sharing the luck

Vampire Survivors taught a masterclass in momentum. Ship small, listen hard, and protect the core that made people smile. The surprising part wasn’t just sales; it was how strongly players rewarded candor and iteration. That energy shapes every decision at Poncle Presents. We’d rather promise less and deliver on time than chase headlines with features that won’t land. We’d rather explain a cut than bury it. And we’d rather support a modest hit that delights a niche than contort a design to chase a hypothetical mass market. Sharing the luck means using the head start to prove a better way exists, one where creators feel safe to be specific and players feel safe to buy in early.

The road ahead: partnerships, platforms, and sustainable cadence

Growth doesn’t have to mean bloat. The healthiest path forward is measured: a few releases a year, each with room for polish and post-launch touch-ups, plus selective platform partnerships when they let small projects punch above their weight. We’ll continue looking for ideas that are easy to explain, satisfying on pad or keyboard, and priced so a curious player can say “why not?” without a second thought. If that sounds quaint in an age of mega-franchises, that’s fine. There’s a big audience for small, confident games that don’t apologize for being focused. As long as we keep that promise—clear scope, stable launches, respectful monetization—the library will age well and the trust we build now will make the next greenlight easier.

How developers can prepare to pitch and keep control

Come with a playable loop, a trimmed scope, and a patch plan you can execute with your current headcount. Show a trailer that teaches by seeing, not by telling, and keep the deck to the essentials: hook, inputs, session length, progression model, and the two updates you’d ship post-launch. Be explicit about what features you won’t build and why. If your budget assumes a miracle, scale down until it doesn’t. The strongest pitches feel inevitable—you can see the game, you can feel the cadence, and you can measure the risks. When that clarity is there, a publisher doesn’t need to take your wheel; they just need to fuel the journey and clear the roadblocks.

What players should expect when they see our label

Expect tight loops, honest scope, and support that shows up. Expect pricing that respects your time and regional realities. Expect patch notes that read like a conversation, not a legal filing. Most of all, expect games that know exactly what they are—and have the courage to stay that way. If something changes, you’ll hear it from us first. If something goes wrong, we’ll fix it in the open. That’s the compact we’re making. If we keep it, we’ll earn the only currency that matters long-term: trust.

Conclusion

Poncle Presents is a simple promise made concrete: back genuine projects, protect small teams from scope creep, and keep supporting releases after launch. By rejecting exploitative habits and centering clear scope, fair pricing, and candid communication, we set expectations everyone can live with. The early catalog shows the shape of that promise—focused ideas that deliver now and improve steadily instead of chasing headlines. If we hold that line, we help rebuild confidence in indie publishing one stable launch at a time.

FAQs
  • Why create a publishing label after Vampire Survivors?
    • Because success revealed a path worth repeating: ship focused ideas, communicate clearly, and keep supporting players. A label lets us fund and mentor other small teams without diluting their vision.
  • What kinds of projects fit best?
    • Compact, identity-driven games with a clear loop and modest scope. If it explains itself in one sentence and plays great in one minute, we’re listening.
  • How do you approach monetization?
    • Keep it respectful. Price to scope, avoid power-tied purchases, and add cosmetics only when they’re truly optional. No surprise costs, no pressure tactics.
  • Will every release get post-launch updates?
    • Yes—at a scale that matches team size. Expect stability patches, quality-of-life tweaks, and selective content that deepens replayability without bloating the design.
  • How can developers pitch?
    • Bring a playable build, a realistic roadmap, and clarity on what you’re not building. Show how the first patch improves the first session, and be ready to talk openly about risks.
Sources
WhatsAppMessengerLinkedInRedditPinterestBufferSMS