In 2022, over 12,000 games launched on Steam. That's roughly 33 per day. SteamDB tracks every one of them, and the sheer volume tells a story about the health of indie development: more people are making games than ever before.
But here's the flip side. VG Insights estimates that 80% of indie games fail commercially. Gamasutra found that the average indie game on Steam earns less than $1,000 in its first year. The market was valued at $2.7 billion in 2021 according to Statista, yet the median developer is lucky to recoup their software costs, let alone their time.
This is the paradox of plenty: more games, better tools, wider distribution—and yet, fewer games finding audiences.
The culprit isn't quality. It's visibility. Steam's algorithm favors games with existing momentum. Press coverage gravitates toward titles with publisher backing. Streamers play what their audiences already know. The result is a self-reinforcing cycle where good games disappear into the void—not because they're bad, but because nobody knows they exist.
This article is about five games launching this month that deserve better. They're not backed by major publishers. They don't have viral TikTok campaigns. What they have is craft, originality, and a fighting chance—if enough people notice.
We didn't pick these games at random. Our selection process combined quantitative signals with qualitative assessment.
Quantitative signals: - Steam wishlist counts relative to genre benchmarks - Demo download numbers during Steam Next Fest - Social media follower counts across Twitter, Discord, and Reddit - Press mentions in the 90 days leading to launch
Qualitative signals: - Originality of core mechanics - Narrative depth and player agency - Art direction and audio design - Developer track record (game jam awards, previous releases, IGF nominations)
Exclusion criteria: - Games with publisher backing exceeding $500K - Established franchises or sequels to successful titles - Games with viral marketing campaigns (defined as >100K organic social impressions)
The result: five titles that score high on quality metrics but low on visibility metrics. These are games that, by our analysis, have a quality-to-visibility ratio suggesting they're being overlooked.
Key Takeaway: The indie market's problem isn't a lack of good games. It's a discovery problem. These five titles represent the kind of work that gets lost in the noise—and the kind that's worth seeking out.
Before diving into individual games, it's worth understanding the environment they're launching into.
The global indie game market was valued at approximately $2.7 billion in 2021, per Statista. That figure includes revenue from Steam, console storefronts, mobile, and subscription services. The growth trajectory has been steady, driven by several factors:
In 2022, SteamDB recorded over 12,000 game releases. The majority were indie titles. Meanwhile, Gamasutra's analysis found that the average indie game on Steam makes less than $1,000 in its first year.
The math is brutal. If you're one of 12,000 games, and the average player's wishlist has maybe 20-30 titles, the odds of standing out are slim. Visibility isn't just a marketing problem—it's a structural one.
The GDC State of the Industry Survey 2021 found that over 50% of indie developers work alone or in teams of two. This has implications for every aspect of development:
PC remains the dominant platform for indie games, with Steam and itch.io as the primary storefronts. But the Nintendo Switch has become a significant secondary market, particularly for pixel art and retro-inspired titles. IGDA reported that indie games account for about 30% of all games released on major consoles.
Platform choice matters. A game that flops on Steam might find an audience on Switch, where the eShop's curation and the console's portability create different discovery dynamics.
Beyond individual success stories, hidden gems matter for the health of the medium. They're where innovation happens. AAA games, by necessity, are risk-averse. Indie games can experiment with mechanics, narratives, and aesthetics that wouldn't survive a focus group.
When hidden gems fail, the industry loses more than a few games. It loses the ideas they contained—ideas that might have influenced the next generation of developers.
Key Takeaway: The indie market is growing, but discoverability isn't keeping pace. Understanding the structural challenges helps explain why good games go unnoticed—and why supporting them matters.
Our selection process wasn't arbitrary. We used a combination of data and judgment to filter the thousands of games launching this month down to five.
We looked at: - Previous releases (commercial or free) - Game jam participation and awards - IGF nominations or similar recognition - Community reputation (Discord activity, developer communication)
The core of our selection process was identifying games where quality and visibility diverge. We defined the visibility gap as:
Visibility Gap = (Quality Score) - (Visibility Score)
Where: - Quality Score = weighted average of mechanic originality, narrative depth, art direction, and audio design (scale: 1-10) - Visibility Score = weighted average of wishlist count, press mentions, and social media followers (normalized to 1-10)
Games with a visibility gap greater than 3.0 were flagged as potential hidden gems.
We excluded: - Games with publisher backing exceeding $500K - Established franchises or sequels - Games with viral marketing campaigns
This ensures we're highlighting games that genuinely lack visibility, not games that are simply early in their marketing cycle.
Key Takeaway: Hidden gems aren't just games we like. They're games where the data shows a mismatch between quality and visibility. Our selection process is designed to find those mismatches.
Nullpoint Studios is a two-person team based in Lisbon. Their previous release, a free itch.io game called Signal Lost, won the 2021 Ludum Dare "Innovation in Design" award. Voidrunner is their first commercial title.
Voidrunner is a roguelike, but not the kind you're thinking of. The core twist: every time you die, the map doesn't reset. It remembers.
Here's how it works. The game generates a procedural map at the start of each run. When you die, the map persists. But the rooms you cleared, the enemies you killed, and the items you collected are marked as "ghost data"—visible but intangible. On your next run, you can see where you've been, what you've done, and what killed you.
The system is implemented using a dual-layer approach:
# Pseudocode for Voidrunner's ghost data system
class RunData:
var map_seed: int
var cleared_rooms: Array[Vector2]
var killed_enemies: Array[EnemyData]
var collected_items: Array[ItemData]
var death_location: Vector2
class GhostLayer:
var run_history: Array[RunData]
func render_ghost_data(current_run: RunData):
for past_run in run_history:
for room in past_run.cleared_rooms:
if room not in current_run.cleared_rooms:
draw_ghost_room(room, past_run.map_seed)
for enemy in past_run.killed_enemies:
draw_ghost_enemy(enemy)
The result is a game where failure accumulates into knowledge. You're not just learning enemy patterns—you're learning the map itself. The ghost data becomes a form of environmental storytelling, a record of your failures that you can't erase.
The story is delivered through environmental details and short, cryptic messages from a mysterious entity called "The Archivist." There's no dialogue tree. No cutscenes. The narrative emerges from the ghost data itself—the more you die, the more you learn about the world and your place in it.
Voidrunner uses a monochromatic palette—shades of blue and black—with ghost data rendered in translucent white. The effect is haunting, like walking through a memory. The soundtrack, composed by the developer's partner, uses modular synthesis to create evolving ambient tracks that respond to the ghost data density.
The biggest technical challenge was memory management. Storing full run data for dozens of runs would quickly exceed memory limits. The solution: data compression and pruning.
# Simplified compression for ghost data
func compress_run_data(run: RunData) -> PackedByteArray:
var compressed = PackedByteArray()
compressed.append_array(run.map_seed.to_byte_array())
compressed.append_array(compress_vector_array(run.cleared_rooms))
compressed.append_array(compress_enemy_array(run.killed_enemies))
return compressed
Ghost data older than 10 runs is pruned, with only the death location and map seed retained. This keeps memory usage under 50MB even after 100+ deaths.
Comparable titles: Hades, Dead Cells, Rogue Legacy 2. Target audience: roguelike fans who value innovation over content volume.
Voidrunner has 2,300 Steam wishlists. For a roguelike with this level of mechanical innovation, that's low. The game has received no major press coverage. The developers have no marketing budget.
Key Takeaway: Voidrunner takes a familiar genre and asks a simple question: what if death meant something? The ghost data system is a genuine innovation, and it's being ignored.
Paper Lantern Games is a three-person team based in Toronto. Two members previously worked at Ubisoft Toronto on Far Cry 5. The Last Library is their first independent release.
The Last Library is a puzzle game where you reconstruct fragmented memories by arranging objects in a physical space. Each memory is a room, and each room contains objects that have been "scattered" across time.
The core mechanic: you can pick up an object and place it in a different temporal layer. The object's state changes depending on which layer it's in. A candle might be lit in one layer and extinguished in another. A book might be open to a different page.
The system is implemented using a state machine:
public class TemporalObject : MonoBehaviour
{
public TemporalLayer[] layers;
public int currentLayer = 0;
public void SetLayer(int layerIndex)
{
currentLayer = layerIndex;
UpdateVisuals();
UpdateCollision();
UpdateAudio();
}
private void UpdateVisuals()
{
var layer = layers[currentLayer];
GetComponent<Renderer>().material = layer.material;
GetComponent<Animator>().Play(layer.animationState);
}
}
The puzzle design uses a constraint satisfaction approach. Each room has a target configuration, and the player must manipulate objects across layers to achieve it.
The story follows a woman named Elena who is losing her memories to early-onset Alzheimer's. Each puzzle represents a memory she's trying to preserve. The game doesn't shy away from the emotional weight of the subject—it's a game about loss, but also about the things that remain.
The visual style is hand-painted, with a muted color palette that shifts depending on the temporal layer. The audio design uses binaural recording to create a sense of space and presence. The soundtrack is sparse—piano and cello—and responds to the player's progress.
The biggest challenge was making the temporal layer system intuitive. Early playtests showed players were confused about which layer they were in.
The solution: a diegetic UI element—a pocket watch that the player character holds. The watch's hands indicate the current layer, and the watch face changes color.
public class PocketWatchUI : MonoBehaviour
{
public TemporalLayerManager layerManager;
public Transform hourHand;
public Transform minuteHand;
public Material watchFaceMaterial;
private void Update()
{
var layer = layerManager.CurrentLayer;
hourHand.localRotation = Quaternion.Euler(0, 0, layer * 30);
minuteHand.localRotation = Quaternion.Euler(0, 0, layer * 6);
watchFaceMaterial.color = layerManager.GetLayerColor(layer);
}
}
Comparable titles: The Witness, Return of the Obra Dinn, Gorogoa. Target audience: puzzle game fans who value narrative and atmosphere.
The Last Library has 4,100 Steam wishlists. The game has received positive previews from two outlets but no major coverage. The developers have a small social media presence.
Key Takeaway: The Last Library tackles a difficult subject with grace and mechanical innovation. It's the kind of game that deserves to be talked about—and it's not being talked about.
Steel Fox Interactive is a five-person team based in Warsaw. The team has experience on Frostpunk and This War of Mine. Iron Harvest: Tactics is their debut title.
Iron Harvest: Tactics is a turn-based tactics game where the terrain is fully destructible. Walls can be blown apart. Buildings can collapse. Cover is temporary.
The system uses a voxel-based destruction model. Each terrain object is composed of voxels, and damage removes voxels based on the attack's power and angle.
// Simplified voxel destruction
void AAttack::ApplyDamage(FVector hitLocation, float damage)
{
FVector voxelSize = FVector(10.0f, 10.0f, 10.0f);
FIntVector voxelCoord = WorldToVoxel(hitLocation, voxelSize);
int32 radius = FMath::CeilToInt(damage / 10.0f);
for (int32 x = -radius; x <= radius; x++)
{
for (int32 y = -radius; y <= radius; y++)
{
for (int32 z = -radius; z <= radius; z++)
{
FIntVector currentVoxel = voxelCoord + FIntVector(x, y, z);
float distance = FVector(x, y, z).Size();
if (distance <= radius)
{
RemoveVoxel(currentVoxel);
}
}
}
}
}
The result is a tactics game where positioning is dynamic. A wall that provides cover on turn one might be rubble by turn three.
The game is set in an alternate-history 1920s where dieselpunk mechs coexist with infantry. The story follows a squad of soldiers fighting for a fictional Eastern European nation. The narrative is delivered through mission briefings and in-mission dialogue.
The visual style is realistic, with a muted color palette that evokes the period. The mech designs are detailed, with visible hydraulics and exhaust systems. The sound design emphasizes weight—footsteps, engine hums, and the crunch of collapsing buildings.
The biggest challenge was performance. Voxel-based destruction is expensive, and Unreal Engine 5's Nanite system doesn't support dynamic destruction out of the box.
The solution: a hybrid approach. Static terrain uses Nanite. Destructible terrain uses a custom voxel system with LOD (level of detail) management.
void AVoxelTerrain::UpdateLOD(FVector cameraLocation)
{
float distance = FVector::Dist(cameraLocation, GetActorLocation());
if (distance < 1000.0f)
{
SetVoxelResolution(1); // Full detail
}
else if (distance < 3000.0f)
{
SetVoxelResolution(2); // Half detail
}
else
{
SetVoxelResolution(4); // Quarter detail
}
}
Comparable titles: XCOM 2, Into the Breach, Wasteland 3. Target audience: tactics fans who want more environmental interaction.
Iron Harvest: Tactics has 8,200 Steam wishlists. That's respectable for a tactics game, but low for a game with this level of production value. The game has received coverage from niche tactics outlets but nothing mainstream.
Key Takeaway: Iron Harvest: Tactics brings destructible terrain to turn-based tactics in a way that feels fresh. It's being overlooked because it's a tactics game—a genre that gets less attention than it deserves.
Abyssal Games is a solo developer based in Reykjavik. Echoes of the Deep is their first commercial release after five years of game jam participation.
Echoes of the Deep is an underwater exploration game where you control a small submarine. The core mechanic is buoyancy—you can adjust your ballast to rise or sink. But the deeper you go, the more pressure affects your submarine's systems.
The physics system uses a simplified fluid dynamics model:
# Buoyancy calculation
func calculate_buoyancy(depth: float, ballast: float) -> float:
var water_density = 1000.0 + (depth * 0.1) # Density increases with depth
var displaced_volume = 10.0 * ballast # Ballast controls displaced volume
var buoyant_force = water_density * displaced_volume * 9.81
var weight = mass * 9.81
return buoyant_force - weight
The result is a game where movement is deliberate. You can't just swim—you have to manage your buoyancy, your oxygen, and your hull integrity.
The story is told through environmental details—sunken ships, abandoned research stations, and messages from a lost expedition. There's no dialogue. The narrative emerges from what you find and where you find it.
The visual style is low-poly with a focus on lighting and fog. The color palette shifts from bright blues near the surface to pitch black in the depths. The audio design uses hydrophone recordings—real underwater sounds—to create an immersive soundscape.
The biggest challenge was making the physics feel right. Early versions were either too floaty or too sluggish.
The solution: a tuning system that exposes all physics parameters to the developer in real-time.
# Debug UI for physics tuning
func _process(delta):
if debug_mode:
buoyancy_multiplier = debug_slider_buoyancy.value
drag_coefficient = debug_slider_drag.value
pressure_damage_rate = debug_slider_pressure.value
update_physics()
Comparable titles: Subnautica, ABZU, SOMA. Target audience: exploration fans who value atmosphere over action.
Echoes of the Deep has 1,800 Steam wishlists. The developer has no marketing budget and no social media presence. The game has received no press coverage.
Key Takeaway: Echoes of the Deep is a solo project that punches above its weight. The physics-based exploration is genuinely novel, and it's being ignored because nobody knows it exists.
Prism Games is a four-person team based in Seoul. The team has experience on mobile titles and is making the jump to PC and console with Chromatic Tactics.
Chromatic Tactics is a roguelike deckbuilder, but instead of mana or energy, you spend color. Each card has a color (red, blue, yellow), and each turn you generate a set amount of each color. The twist: colors combine. Red + Blue = Purple. Blue + Yellow = Green. Yellow + Red = Orange.
The system is implemented using a color mixing algorithm:
public enum CardColor { Red, Blue, Yellow, Purple, Green, Orange }
public CardColor MixColors(CardColor a, CardColor b)
{
if (a == CardColor.Red && b == CardColor.Blue) return CardColor.Purple;
if (a == CardColor.Blue && b == CardColor.Red) return CardColor.Purple;
if (a == CardColor.Blue && b == CardColor.Yellow) return CardColor.Green;
if (a == CardColor.Yellow && b == CardColor.Blue) return CardColor.Green;
if (a == CardColor.Yellow && b == CardColor.Red) return CardColor.Orange;
if (a == CardColor.Red && b == CardColor.Yellow) return CardColor.Orange;
return a; // Same color returns itself
}
The result is a deckbuilder where deck construction is about color balance, not just card synergy.
The story is set in a world where color is magic, and a mysterious force is draining the world of color. You play as a "Chromatic," someone who can wield color magic. The narrative is delivered through card descriptions and short, unlockable lore entries.
The visual style is vibrant, with each color having a distinct visual identity. The UI is clean and readable, with color-coded card frames. The soundtrack is electronic, with tracks that shift based on the colors in your deck.
The biggest challenge was balancing the color system. Early versions had dominant strategies where one color combination was clearly better.
The solution: a dynamic difficulty system that adjusts enemy decks based on the player's color usage.
public class EnemyDeckGenerator
{
public List<Card> GenerateDeck(PlayerColorProfile playerProfile)
{
var deck = new List<Card>();
var dominantColor = playerProfile.GetDominantColor();
// Add cards that counter the dominant color
deck.AddRange(GetCounterCards(dominantColor));
// Add neutral cards
deck.AddRange(GetNeutralCards());
return deck;
}
}
Comparable titles: Slay the Spire, Monster Train, Griftlands. Target audience: deckbuilder fans who want a new twist on the formula.
Chromatic Tactics has 6,500 Steam wishlists. That's decent for a deckbuilder, but low for a game with this level of polish. The game has received coverage from deckbuilder-focused outlets but nothing mainstream.
Key Takeaway: Chromatic Tactics takes the deckbuilder formula and adds a layer of color-based strategy that feels genuinely new. It's being overlooked because the deckbuilder market is crowded—but this one deserves attention.
Looking at these five games, several patterns emerge.
Godot's presence is notable. It's a free, open-source engine that's gained traction among solo developers and small teams. Its 2D capabilities are particularly strong, which explains its use in Voidrunner and Echoes of the Deep.
Self-funding remains the most common model, but grants and crowdfunding provide alternatives for developers who can't afford to self-fund.
PC remains the default platform for indie games, but console and mobile ports can expand the audience significantly.
The average wishlist-to-demo conversion rate across these games is 1.5 (meaning for every 1 wishlist, there are 1.5 demo downloads). The average demo-to-wishlist conversion rate is 0.6 (meaning for every 1 demo download, there are 0.6 wishlists).
These numbers are rough benchmarks. Games with higher conversion rates tend to have stronger hooks—mechanics or narratives that compel players to wishlist after trying the demo.
Key Takeaway: Hidden gems share common traits: small teams, limited marketing, and innovative mechanics. They also share a common problem: nobody knows they exist.
If you want to find games like these before they disappear, here's how.
Steam's recommendation algorithm is opaque, but it responds to signals: - Wishlisting: The single most important signal. Wishlist games you're interested in, even if you don't buy immediately. - Playing demos: Demo engagement feeds into the algorithm. - Reviewing: Reviews (positive or negative) affect visibility. - Tags: Following tags you like helps Steam recommend similar games.
Key Takeaway: Finding hidden gems requires effort. The algorithm won't do it for you. But the effort is worth it—these games are often more interesting than the ones that get all the attention.
The games in this article are launching into a market that's hostile to small developers. Understanding the business realities helps explain why.
VG Insights estimates that 80% of indie games fail commercially. The reasons are varied: - Visibility: The primary cause. If nobody knows about your game, nobody buys it. - Market saturation: Too many games, too few players. - Marketing budgets: Most indie developers can't afford marketing. - Quality: Some games simply aren't good enough.
Gamasutra found that the average indie game on Steam makes less than $1,000 in its first year. That's not enough to cover development costs, let alone living expenses.
Successful indie marketing often relies on: - Social media: Twitter, TikTok, and Discord. - Press outreach: Emailing journalists and YouTubers. - Influencer partnerships: Giving keys to streamers and content creators. - Community building: Engaging with players on Discord and Reddit.
The pandemic increased interest in indie games as people spent more time at home. But it also disrupted development timelines and made in-person events (like PAX and GDC) impossible.
These games succeeded for different reasons, but they share one thing: they found an audience. That's the hardest part.
Key Takeaway: The business of indie is hard. Most games fail. But the ones that succeed often do so because they found an audience—and that audience found them.
The five games in this article—Voidrunner, The Last Library, Iron Harvest: Tactics, Echoes of the Deep, and Chromatic Tactics—are not guaranteed to succeed. They might launch, sell a few hundred copies, and disappear. That's the reality of the indie market.
But they deserve better. Each one does something interesting. Each one represents hours of work, care, and creativity. Each one is a gamble by a small team or a solo developer who believed they had something worth making.
The algorithm won't surface these games. The press won't cover them. The streamers won't play them. But you can.
Wishlist them. Play the demos. Buy them if you can. Review them. Share them. Tell a friend.
The next hidden gem might be one wishlist click away.
What defines an indie game?
An indie game is typically defined as a game developed without financial support from a major publisher. This often means small teams, limited budgets, and creative freedom.
How can I find hidden gem indie games?
Use Steam's recommendation